From bec4fb9976337d23b51055486a968ccd95a297ac Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Fri, 14 Jul 2023 15:49:23 -0400
Subject: [PATCH 01/50] updated readme

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 39d3988..95f2984 100644
--- a/README.md
+++ b/README.md
@@ -49,11 +49,11 @@ Further information can be found in the ZSSP whitepaper (pending official releas
 * **Forward Secret Identity Hiding**: An attacker with the static private key of one or more parties cannot determine the identity of everyone they have previously communicated with.
 * **Quantum Forward Secret**: A quantum computer powerful enough to break Elliptic-curve cryptography is not sufficient in order to decrypt recordings of messages sent between parties.
 * **Ratcheted Forward Secrecy**: In order to break forward secrecy an attacker must record and break every single key exchange two parties perform, in order, starting from the first time they began communicating. Improves secrecy under weak or compromised RNG.
+* **Silence is a Virtue**: A server running the protocol can be configured in such a way that it will not respond to an unauthenticated, anonymous or replayed message.
 * **Key-Compromise Impersonation**: The attacker has a memory image of a single party, and attempts to create a brand new session with that party, pretending to be someone else.
 * **Compromise-and-Impersonate**: The attacker has a memory image of a single party, and attempts to impersonate them on a brand new session with the other party.
 * **Single Key-Compromise MitM**: The attacker has a memory image of a single party, and attempts to become a Man-in-the-Middle between them and any other party.
 * **Double Key-Compromise MitM**: The attacker has a memory image of both parties, and attempts to become a Man-in-the-Middle between them.
-* **Silence is a Virtue**: A server running the protocol can be configured in such a way that it will not respond to an unauthenticated, anonymous or replayed message.
 * **Supports Fragmentation**: Transmission data can be fragmented into smaller units to support jumbo-sized data or MTU discovery.
 * **FIPS Compliant**: The protocol uses FIPS approved cryptographic algorithms.
 * **Small Code Footprint**: The Codebase implementing the protocol can be easily audited by anyone on the internet.

From 7c8ff59408168ff603f527f358a9581a140a48bd Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 19 Jul 2023 14:04:33 -0400
Subject: [PATCH 02/50] fixed typo

---
 src/log_event.rs | 4 ++--
 src/zssp.rs      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/log_event.rs b/src/log_event.rs
index 3c033f7..bdc94b5 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -36,7 +36,7 @@ pub enum LogEvent<'a, Application: ApplicationLayer> {
     ReceiveUncheckedKK2,
     ReceiveValidKK2(&'a Arc<Session<Application>>),
     ReceiveValidKeyConfirm(&'a Arc<Session<Application>>),
-    ReceiveValidKeyDelete(&'a Arc<Session<Application>>),
+    ReceiveValidAck(&'a Arc<Session<Application>>),
 }
 impl<'a, Application: ApplicationLayer> std::fmt::Debug for LogEvent<'a, Application> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -68,7 +68,7 @@ impl<'a, Application: ApplicationLayer> std::fmt::Debug for LogEvent<'a, Applica
             ReceiveUncheckedKK2 => write!(f, "ReceiveUncheckedKK2"),
             ReceiveValidKK2(_) => write!(f, "ReceiveValidKK2"),
             ReceiveValidKeyConfirm(_) => write!(f, "ReceiveValidKeyConfirm"),
-            ReceiveValidKeyDelete(_) => write!(f, "ReceiveValidKeyDelete"),
+            ReceiveValidAck(_) => write!(f, "ReceiveValidAck"),
         }
     }
 }
diff --git a/src/zssp.rs b/src/zssp.rs
index 897391b..40a58b1 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -1901,7 +1901,7 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
         }
         PACKET_TYPE_ACK => {
             drop(state);
-            app.event_log(LogEvent::ReceiveValidKeyDelete(&session), current_time);
+            app.event_log(LogEvent::ReceiveValidAck(&session), current_time);
             let kex_lock = session.state_machine_lock.lock().unwrap();
             let mut state = session.state.write().unwrap();
             // Check if we should end any current offers and transition back to Normal state

From ce9e64448d57bd7a7d95e68fe4b1afb28affca31 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 19 Jul 2023 17:43:05 -0400
Subject: [PATCH 03/50] updated docs

---
 src/zssp.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/zssp.rs b/src/zssp.rs
index 40a58b1..e1bed47 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -581,7 +581,9 @@ impl<Application: ApplicationLayer> Context<Application> {
     /// * `check_accept_session` - Function to accept sessions after final negotiation.
     ///   The second argument is the identity blob that the remote peer sent us. The application
     ///   must verify this identity is associated with the remote peer's static key.
-    ///   The third argument is true if the remote peer connected to us with a recognized ratchet fingerprint.
+    ///   The third argument is the ratchet chain length, or ratchet count.
+    ///   To prevent desync, if this function returns (Some(_), _), no other open session with the
+    ///   same remote peer must exist.
     /// * `send_unassociated_reply` - Function to send reply packets directly when no session exists
     /// * `send_unassociated_mtu` - MTU for unassociated replies
     /// * `send_to` - Function to get senders for existing sessions, permitting MTU and path lookup
@@ -2228,8 +2230,8 @@ impl<Application: ApplicationLayer> Session<Application> {
         self.state.read().unwrap().ratchet_states[0].chain_len()
     }
     /// Mark a session as expired. This will make it impossible for this session to successfully
-    /// receive or send data. It is recommended to simply `drop` the session instead, but this can
-    /// provide some reassurance in complex shared ownership situations.
+    /// receive or send data or control packets. It is recommended to simply `drop` the session
+    /// instead, but this can provide some reassurance in complex shared ownership situations.
     pub fn expire(&self) {
         if let Some(context) = self.context.upgrade() {
             self.expire_inner(&context, &mut context.session_queue.lock().unwrap());

From 8468213814014b191e0c35d94af480517b379111 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 19 Jul 2023 18:12:29 -0400
Subject: [PATCH 04/50] fixed minor race condition

---
 src/zssp.rs | 252 +++++++++++++++++++++++++++-------------------------
 1 file changed, 131 insertions(+), 121 deletions(-)

diff --git a/src/zssp.rs b/src/zssp.rs
index e1bed47..8896b6f 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -234,6 +234,7 @@ enum NoiseXKAliceHandshakeState<Application: ApplicationLayer> {
         noise_message: [u8; NoiseXKPattern3::MAX_SIZE],
         noise_message_len: usize,
     },
+    Rejected,
 }
 
 struct SessionKey<Application: ApplicationLayer> {
@@ -390,6 +391,7 @@ impl<Application: ApplicationLayer> Context<Application> {
                                         Some(&session.header_send_cipher),
                                     );
                                 }
+                                NoiseXKAliceHandshakeState::Rejected => {}
                             }
                         }
                         retry_next
@@ -501,8 +503,12 @@ impl<Application: ApplicationLayer> Context<Application> {
                 let mut session_map = self.0.session_map.write().unwrap();
                 let local_key_id = generate_key_id(&session_map, &mut self.0.rng.lock().unwrap());
                 // Begin Noise XKhfs+psk2.
-                let (offer, a2b_header_key, b2a_header_key) =
-                    NoiseXKAliceHandshake::<Application>::initialize(local_key_id, &remote_static_key, &ratchet_states, &mut self.0.rng.lock().unwrap())?;
+                let (offer, a2b_header_key, b2a_header_key) = NoiseXKAliceHandshake::<Application>::initialize(
+                    local_key_id,
+                    &remote_static_key,
+                    &ratchet_states,
+                    &mut self.0.rng.lock().unwrap(),
+                )?;
                 let handshake_state = Box::new(NoiseXKAliceHandshake {
                     next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
                     timeout: current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS),
@@ -558,9 +564,7 @@ impl<Application: ApplicationLayer> Context<Application> {
 
                 Ok(session)
             }
-            Err(e) => {
-                Err(OpenError::RatchetIoError(e))
-            }
+            Err(e) => Err(OpenError::RatchetIoError(e)),
         }
     }
 
@@ -681,7 +685,7 @@ impl<Application: ApplicationLayer> Context<Application> {
                                 }
                                 // This error can occur naturally if Bob's initial reply to Alice had a
                                 // resend that was delayed massively and arrived out of order.
-                                NoiseXKAliceHandshakeState::NoiseXKPattern3 { .. } => return Err(byzantine_fault!(FaultType::OutOfSequence, true)),
+                                _ => return Err(byzantine_fault!(FaultType::OutOfSequence, true)),
                             },
                             _ => return Err(byzantine_fault!(FaultType::OutOfSequence, false)),
                         };
@@ -1519,114 +1523,114 @@ impl<Application: ApplicationLayer> Context<Application> {
                         let result = app.restore_by_identity(&remote_s_public_key, &application_data, current_time);
                         match result {
                             Ok(true_ratchet_states) => {
-                            let mut has_match = false;
-                            for rs in &true_ratchet_states {
-                                if !rs.is_null() {
-                                    has_match |= &handshake_state.ratchet_state == rs;
-                                }
-                            }
-                            if !has_match {
-                                if !responder_disallows_downgrade && handshake_state.ratchet_state.is_empty() {
-                                    // TODO: add some kind of warning callback or signal.
-                                } else {
-                                    if !responder_silently_rejects {
-                                        send_reject();
+                                let mut has_match = false;
+                                for rs in &true_ratchet_states {
+                                    if !rs.is_null() {
+                                        has_match |= &handshake_state.ratchet_state == rs;
                                     }
+                                }
+                                if !has_match {
+                                    if !responder_disallows_downgrade && handshake_state.ratchet_state.is_empty() {
+                                        // TODO: add some kind of warning callback or signal.
+                                    } else {
+                                        if !responder_silently_rejects {
+                                            send_reject();
+                                        }
+                                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                                    }
+                                }
+
+                                let mut noise_kk_ss = Secret::new();
+                                if !self.0.static_keypair.agree(&remote_s_public_key, noise_kk_ss.as_mut()) {
                                     return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
                                 }
-                            }
+                                let noise_kk_local_init_h = mix_hash(sha512, &INITIAL_H_REKEY, self.0.static_keypair.public_key_bytes());
+                                let noise_kk_local_init_h = mix_hash(sha512, &noise_kk_local_init_h, remote_s_public_key.as_bytes());
+                                let noise_kk_remote_init_h = mix_hash(sha512, &INITIAL_H_REKEY, remote_s_public_key.as_bytes());
+                                let noise_kk_remote_init_h = mix_hash(sha512, &noise_kk_remote_init_h, self.0.static_keypair.public_key_bytes());
 
-                            let mut noise_kk_ss = Secret::new();
-                            if !self.0.static_keypair.agree(&remote_s_public_key, noise_kk_ss.as_mut()) {
-                                return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                            }
-                            let noise_kk_local_init_h = mix_hash(sha512, &INITIAL_H_REKEY, self.0.static_keypair.public_key_bytes());
-                            let noise_kk_local_init_h = mix_hash(sha512, &noise_kk_local_init_h, remote_s_public_key.as_bytes());
-                            let noise_kk_remote_init_h = mix_hash(sha512, &INITIAL_H_REKEY, remote_s_public_key.as_bytes());
-                            let noise_kk_remote_init_h = mix_hash(sha512, &noise_kk_remote_init_h, self.0.static_keypair.public_key_bytes());
+                                let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_ee1peekem1pskpsp);
+                                // We must make sure the ratchet key is saved before we transition.
+                                let new_ratchet_state =
+                                    RatchetState::new_nonempty(rk, rf, NonZeroU64::new(handshake_state.ratchet_state.chain_len() + 1).unwrap());
+                                let result = app.save_ratchet_state(
+                                    &remote_s_public_key,
+                                    &application_data,
+                                    [&true_ratchet_states[0], &true_ratchet_states[1]],
+                                    [&new_ratchet_state, &RatchetState::Null],
+                                    current_time,
+                                );
+                                if let Err(e) = result {
+                                    return Err(ReceiveError::RatchetIoError(e));
+                                }
 
-                            let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_ee1peekem1pskpsp);
-                            // We must make sure the ratchet key is saved before we transition.
-                            let new_ratchet_state =
-                                RatchetState::new_nonempty(rk, rf, NonZeroU64::new(handshake_state.ratchet_state.chain_len() + 1).unwrap());
-                            let result = app.save_ratchet_state(
-                                &remote_s_public_key,
-                                &application_data,
-                                [&true_ratchet_states[0], &true_ratchet_states[1]],
-                                [&new_ratchet_state, &RatchetState::Null],
-                                current_time,
-                            );
-                            if let Err(e) = result {
+                                let mut session_queue = self.0.session_queue.lock().unwrap();
+                                let queue_idx = session_queue.reserve_index();
+                                let session = Arc::new(Session {
+                                    context: Arc::downgrade(&self.0),
+                                    queue_idx,
+                                    application_data,
+                                    remote_static_key: remote_s_public_key,
+                                    send_counter: AtomicU64::new(INIT_COUNTER),
+                                    session_has_expired: AtomicBool::new(false),
+                                    counter_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
+                                    state_machine_lock: Mutex::new(()),
+                                    state: RwLock::new(SessionMutableState {
+                                        ratchet_states: [new_ratchet_state.clone(), RatchetState::Null],
+                                        cipher_states: [
+                                            Some(SessionKey::new(
+                                                hmac,
+                                                noise_ck,
+                                                handshake_state.local_key_id,
+                                                handshake_state.remote_key_id,
+                                                INIT_COUNTER,
+                                                true,
+                                            )),
+                                            None,
+                                        ],
+                                        current_key: 0,
+                                        outgoing_offer: KeyConfirm {
+                                            next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
+                                            timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
+                                        },
+                                    }),
+                                    header_receive_cipher: Application::PrpDec::new(handshake_state.header_receive_key.as_ref()),
+                                    header_send_cipher,
+                                    kex_send_cipher: Mutex::new(Some(Application::AeadEnc::new(kex_key_b2a.as_ref()))),
+                                    kex_receive_cipher: Mutex::new(Some(Application::AeadDec::new(kex_key_a2b.as_ref()))),
+                                    noise_kk_ss,
+                                    noise_kk_local_init_h,
+                                    noise_kk_remote_init_h,
+                                    defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
+                                    was_bob: true,
+                                });
+                                let timer = Reverse(current_time.saturating_add(Application::RETRY_INTERVAL_MS));
+                                session_queue.push_reserved(queue_idx, Arc::downgrade(&session), timer);
+                                drop(session_queue);
+                                // There is the miniscule possibility this key id is already
+                                // in use, in which case we have to drop this session like
+                                // nothing ever happened.
+                                let mut session_map = self.0.session_map.write().unwrap();
+                                if let std::collections::hash_map::Entry::Vacant(e) = session_map.entry(handshake_state.local_key_id) {
+                                    e.insert((Arc::downgrade(&session), false));
+                                    drop(session_map);
+                                    let _ =
+                                        session.send_control(&session.state.read().unwrap(), send_unassociated_reply, PACKET_TYPE_KEY_CONFIRM, &[]);
+
+                                    app.event_log(LogEvent::ReceiveValidXK3(&session.application_data), current_time);
+                                    return Ok(ReceiveResult::Session(session, SessionEvent::NewSession));
+                                } else {
+                                    // This can occur if we accidentally generate a key id collision.
+                                    // There is an extremely short amount of time during which
+                                    // another session can steal this session's id, we'll have to
+                                    // restart the handshake in this case.
+                                    return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
+                                }
+                            }
+                            Err(e) => {
                                 return Err(ReceiveError::RatchetIoError(e));
                             }
-
-
-                            let mut session_queue = self.0.session_queue.lock().unwrap();
-                            let queue_idx = session_queue.reserve_index();
-                            let session = Arc::new(Session {
-                                context: Arc::downgrade(&self.0),
-                                queue_idx,
-                                application_data,
-                                remote_static_key: remote_s_public_key,
-                                send_counter: AtomicU64::new(INIT_COUNTER),
-                                session_has_expired: AtomicBool::new(false),
-                                counter_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
-                                state_machine_lock: Mutex::new(()),
-                                state: RwLock::new(SessionMutableState {
-                                    ratchet_states: [new_ratchet_state.clone(), RatchetState::Null],
-                                    cipher_states: [
-                                        Some(SessionKey::new(
-                                            hmac,
-                                            noise_ck,
-                                            handshake_state.local_key_id,
-                                            handshake_state.remote_key_id,
-                                            INIT_COUNTER,
-                                            true,
-                                        )),
-                                        None,
-                                    ],
-                                    current_key: 0,
-                                    outgoing_offer: KeyConfirm {
-                                        next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-                                        timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
-                                    },
-                                }),
-                                header_receive_cipher: Application::PrpDec::new(handshake_state.header_receive_key.as_ref()),
-                                header_send_cipher,
-                                kex_send_cipher: Mutex::new(Some(Application::AeadEnc::new(kex_key_b2a.as_ref()))),
-                                kex_receive_cipher: Mutex::new(Some(Application::AeadDec::new(kex_key_a2b.as_ref()))),
-                                noise_kk_ss,
-                                noise_kk_local_init_h,
-                                noise_kk_remote_init_h,
-                                defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
-                                was_bob: true,
-                            });
-                            let timer = Reverse(current_time.saturating_add(Application::RETRY_INTERVAL_MS));
-                            session_queue.push_reserved(queue_idx, Arc::downgrade(&session), timer);
-                            drop(session_queue);
-                            // There is the miniscule possibility this key id is already
-                            // in use, in which case we have to drop this session like
-                            // nothing ever happened.
-                            let mut session_map = self.0.session_map.write().unwrap();
-                            if let std::collections::hash_map::Entry::Vacant(e) = session_map.entry(handshake_state.local_key_id) {
-                                e.insert((Arc::downgrade(&session), false));
-                                drop(session_map);
-                                let _ = session.send_control(&session.state.read().unwrap(), send_unassociated_reply, PACKET_TYPE_KEY_CONFIRM, &[]);
-
-                                app.event_log(LogEvent::ReceiveValidXK3(&session.application_data), current_time);
-                                return Ok(ReceiveResult::Session(session, SessionEvent::NewSession));
-                            } else {
-                                // This can occur if we accidentally generate a key id collision.
-                                // There is an extremely short amount of time during which
-                                // another session can steal this session's id, we'll have to
-                                // restart the handshake in this case.
-                                return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
-                            }
                         }
-                        Err(e) => {
-                            return Err(ReceiveError::RatchetIoError(e));
-                        }
-                    }
                     } else {
                         if !responder_silently_rejects {
                             send_reject();
@@ -1829,6 +1833,7 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
     fragment: &mut [u8],
     current_time: i64,
 ) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::IoError>> {
+    let kex_lock = session.state_machine_lock.lock().unwrap();
     let state = session.state.read().unwrap();
     let mut c = session.kex_receive_cipher.lock().unwrap();
     let message = decrypt_control(
@@ -1841,17 +1846,25 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
     session.update_receive_window(counter);
     use OfferStateMachine::*;
     return match packet_type {
-        PACKET_TYPE_SESSION_REJECTED => match &state.outgoing_offer {
-            NoiseXKPattern1or3(_) => {
+        PACKET_TYPE_SESSION_REJECTED => {
+            if let NoiseXKPattern1or3(_) = &state.outgoing_offer {
                 drop(state);
+                let mut state = session.state.write().unwrap();
+                if let NoiseXKPattern1or3(state) = &mut state.outgoing_offer {
+                    // We have to make sure that a different thread cannot receive
+                    // `PACKET_TYPE_KEY_CONFIRM` at the same time.
+                    state.offer = NoiseXKAliceHandshakeState::Rejected;
+                }
+                drop(state);
+                drop(kex_lock);
                 Ok(ReceiveResult::Session(session, SessionEvent::Rejected))
+            } else {
+                Err(byzantine_fault!(FaultType::OutOfSequence, false))
             }
-            _ => Err(byzantine_fault!(FaultType::OutOfSequence, false)),
-        },
+        }
         PACKET_TYPE_KEY_CONFIRM => {
             drop(state);
             app.event_log(LogEvent::ReceiveValidKeyConfirm(&session), current_time);
-            let kex_lock = session.state_machine_lock.lock().unwrap();
             let mut state = session.state.write().unwrap();
             // We only want to stop sending NoiseKKPattern2 offers when the latest derived
             // key is confirmed. And we only want to do that once.
@@ -1904,7 +1917,6 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
         PACKET_TYPE_ACK => {
             drop(state);
             app.event_log(LogEvent::ReceiveValidAck(&session), current_time);
-            let kex_lock = session.state_machine_lock.lock().unwrap();
             let mut state = session.state.write().unwrap();
             // Check if we should end any current offers and transition back to Normal state
             if let KeyConfirm { .. } = &state.outgoing_offer {
@@ -1918,10 +1930,6 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
             app.event_log(LogEvent::ReceiveUncheckedKK1, current_time);
             let message = &mut message[..NoiseKKPattern1or2::SIZE];
             let noise_pattern1: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
-
-            drop(state);
-            let kex_lock = session.state_machine_lock.lock().unwrap();
-            let state = session.state.read().unwrap();
             // We need the following operation to be atomic with the change of offer type
             let (should_rekey_as_bob, chosen_id) = match &state.outgoing_offer {
                 // Check rekey rate limits.
@@ -2072,9 +2080,6 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
             let message = &mut message[..NoiseKKPattern1or2::SIZE];
             let noise_pattern2: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
 
-            drop(state);
-            let kex_lock = session.state_machine_lock.lock().unwrap();
-            let state = session.state.read().unwrap();
             if let NoiseKKPattern1 { new_key_id, noise_e_secret, noise_ck, noise_h_pskep, .. } = &state.outgoing_offer {
                 // Noise process pattern2 e token.
                 let mut noise_ee = Secret::new();
@@ -2496,7 +2501,7 @@ fn encrypt_control(
     let fragment_len = packet.len() + HEADER_SIZE + AES_GCM_TAG_SIZE;
 
     c.set_iv(&create_message_nonce(packet_type, counter));
-    if !packet.is_empty(){
+    if !packet.is_empty() {
         fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE].copy_from_slice(packet);
         c.encrypt_in_place(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE]);
     }
@@ -2506,7 +2511,12 @@ fn encrypt_control(
     (fragment, fragment_len)
 }
 #[inline]
-fn decrypt_control<'a, IoError>(c: &mut impl AesGcmDec, packet_type: u8, counter: u64, fragment: &'a mut [u8]) -> Result<&'a mut [u8], ReceiveError<IoError>> {
+fn decrypt_control<'a, IoError>(
+    c: &mut impl AesGcmDec,
+    packet_type: u8,
+    counter: u64,
+    fragment: &'a mut [u8],
+) -> Result<&'a mut [u8], ReceiveError<IoError>> {
     let fragment_len = fragment.len();
     if !(CONTROL_PACKET_MIN_SIZE..=CONTROL_PACKET_MAX_SIZE).contains(&fragment_len) {
         return Err(byzantine_fault!(FaultType::InvalidPacket, false));

From 712fb8b2de0d40a65a2c2e49b34c0252abd8e3cd Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 19 Jul 2023 19:44:41 -0400
Subject: [PATCH 05/50] improved multithreading

---
 src/zssp.rs | 53 +++++++++++++++++++++++++++--------------------------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/src/zssp.rs b/src/zssp.rs
index 8896b6f..8375e48 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -192,6 +192,7 @@ enum OfferStateMachine<Application: ApplicationLayer> {
         next_retry_time: AtomicI64,
         timeout: i64,
     }, // -> Normal
+    Null,
 }
 
 pub(crate) struct NoiseXKBobHandshakeState<Application: ApplicationLayer> {
@@ -234,7 +235,6 @@ enum NoiseXKAliceHandshakeState<Application: ApplicationLayer> {
         noise_message: [u8; NoiseXKPattern3::MAX_SIZE],
         noise_message_len: usize,
     },
-    Rejected,
 }
 
 struct SessionKey<Application: ApplicationLayer> {
@@ -352,15 +352,13 @@ impl<Application: ApplicationLayer> Context<Application> {
                             if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
                                 if handshake_state.timeout <= current_time {
                                     app.event_log(LogEvent::ServiceXKTimeout(&session), current_time);
-                                    if !handshake_state.reinitialize(
+                                    handshake_state.reinitialize(
                                         &session,
                                         &ratchet_state,
                                         &mut self.0.session_map.write().unwrap(),
                                         &mut self.0.rng.lock().unwrap(),
                                         current_time,
-                                    ) {
-                                        session.expire_inner(&self.0, &mut session_queue);
-                                    }
+                                    );
                                 }
                             }
                         } else if let Some((mut send, mut mtu)) = send_to(&session) {
@@ -391,7 +389,6 @@ impl<Application: ApplicationLayer> Context<Application> {
                                         Some(&session.header_send_cipher),
                                     );
                                 }
-                                NoiseXKAliceHandshakeState::Rejected => {}
                             }
                         }
                         retry_next
@@ -404,6 +401,7 @@ impl<Application: ApplicationLayer> Context<Application> {
                         if *timeout <= current_time {
                             app.event_log(LogEvent::ServiceKKTimeout(&session), current_time);
                             next_retry_time.store(i64::MAX, Ordering::Relaxed);
+                            drop(state);
                             session.expire_inner(&self.0, &mut session_queue);
                         } else {
                             let packet_type = if let NoiseKKPattern1 { .. } = &state.outgoing_offer {
@@ -427,6 +425,7 @@ impl<Application: ApplicationLayer> Context<Application> {
                         if *timeout <= current_time {
                             app.event_log(LogEvent::ServiceKeyConfirmTimeout(&session), current_time);
                             next_retry_time.store(i64::MAX, Ordering::Relaxed);
+                            drop(state);
                             session.expire_inner(&self.0, &mut session_queue);
                         } else {
                             app.event_log(LogEvent::ServiceKeyConfirmResend(&session), current_time);
@@ -437,6 +436,7 @@ impl<Application: ApplicationLayer> Context<Application> {
                         retry_next
                     }
                 }
+                Null => retry_next,
             };
             session_queue.change_priority(queue_idx, Reverse(next_timer));
         }
@@ -1850,16 +1850,13 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
             if let NoiseXKPattern1or3(_) = &state.outgoing_offer {
                 drop(state);
                 let mut state = session.state.write().unwrap();
-                if let NoiseXKPattern1or3(state) = &mut state.outgoing_offer {
-                    // We have to make sure that a different thread cannot receive
-                    // `PACKET_TYPE_KEY_CONFIRM` at the same time.
-                    state.offer = NoiseXKAliceHandshakeState::Rejected;
-                }
+                state.outgoing_offer = OfferStateMachine::Null;
                 drop(state);
                 drop(kex_lock);
                 Ok(ReceiveResult::Session(session, SessionEvent::Rejected))
             } else {
-                Err(byzantine_fault!(FaultType::OutOfSequence, false))
+                // This can occur naturally because of control packet resends.
+                Err(byzantine_fault!(FaultType::OutOfSequence, true))
             }
         }
         PACKET_TYPE_KEY_CONFIRM => {
@@ -1877,6 +1874,7 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
                         (false, false, SessionEvent::Control)
                     }
                 }
+                Null => (false, false, SessionEvent::Control),
                 _ => (true, false, SessionEvent::Control),
             };
             if try_delete {
@@ -1915,16 +1913,19 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
             Ok(ReceiveResult::Session(session, ret))
         }
         PACKET_TYPE_ACK => {
-            drop(state);
-            app.event_log(LogEvent::ReceiveValidAck(&session), current_time);
-            let mut state = session.state.write().unwrap();
-            // Check if we should end any current offers and transition back to Normal state
             if let KeyConfirm { .. } = &state.outgoing_offer {
+                drop(state);
+                app.event_log(LogEvent::ReceiveValidAck(&session), current_time);
+                let mut state = session.state.write().unwrap();
+                // Check if we should end any current offers and transition back to Normal state
                 state.outgoing_offer = new_normal_state(context.0.rng.lock().unwrap().next_u64(), current_time);
+                drop(kex_lock);
+                drop(state);
+                Ok(ReceiveResult::Session(session, SessionEvent::Control))
+            } else {
+                // This can occur naturally because of control packet resends.
+                Err(byzantine_fault!(FaultType::OutOfSequence, true))
             }
-            drop(state);
-            drop(kex_lock);
-            Ok(ReceiveResult::Session(session, SessionEvent::Control))
         }
         PACKET_TYPE_NOISE_KK_PATTERN_1 => {
             app.event_log(LogEvent::ReceiveUncheckedKK1, current_time);
@@ -2215,7 +2216,7 @@ impl<Application: ApplicationLayer> Session<Application> {
     #[inline]
     pub fn established(&self) -> bool {
         let state = self.state.read().unwrap();
-        !matches!(&state.outgoing_offer, OfferStateMachine::NoiseXKPattern1or3(_))
+        !matches!(&state.outgoing_offer, OfferStateMachine::NoiseXKPattern1or3(_) | OfferStateMachine::Null)
     }
     /// The static public key of the remote peer.
     #[inline]
@@ -2251,7 +2252,7 @@ impl<Application: ApplicationLayer> Session<Application> {
         session_queue.remove(self.queue_idx);
         self.session_has_expired.store(true, Ordering::Relaxed);
         let _kex_lock = self.state_machine_lock.lock().unwrap();
-        let state = self.state.read().unwrap();
+        let mut state = self.state.write().unwrap();
         let mut session_map = context.session_map.write().unwrap();
         for key in &state.cipher_states {
             if let Some(pre_id) = key.as_ref().map(|k| k.local_key_id) {
@@ -2259,12 +2260,12 @@ impl<Application: ApplicationLayer> Session<Application> {
             }
         }
         use OfferStateMachine::*;
-        let id = match &state.outgoing_offer {
-            NoiseXKPattern1or3(handshake_state) => handshake_state.local_key_id,
-            NoiseKKPattern1 { new_key_id, .. } => *new_key_id,
-            _ => return,
+        match &state.outgoing_offer {
+            NoiseXKPattern1or3(handshake_state) => session_map.remove(&handshake_state.local_key_id),
+            NoiseKKPattern1 { new_key_id, .. } => session_map.remove(new_key_id),
+            _ => None,
         };
-        session_map.remove(&id);
+        state.outgoing_offer = OfferStateMachine::Null;
     }
 
     /// Get the next outgoing counter value.

From 20736ee1088238b1e55ce015e7fb9317a94e29f7 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Sat, 22 Jul 2023 11:50:44 -0400
Subject: [PATCH 06/50] made was_bob pub

---
 src/zssp.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/zssp.rs b/src/zssp.rs
index 8375e48..366307f 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -117,6 +117,8 @@ pub enum IncomingSessionAction {
 pub struct Session<Application: ApplicationLayer> {
     /// An arbitrary application defined object associated with each session.
     pub application_data: Application::Data,
+    /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
+    pub was_bob: bool,
     /// The receive context associated with this session,
     /// only this context can receive messages from the remote peer.
     context: Weak<ContextInner<Application>>,
@@ -145,7 +147,6 @@ pub struct Session<Application: ApplicationLayer> {
     noise_kk_ss: Secret<P384_ECDH_SHARED_SECRET_SIZE>,
     noise_kk_local_init_h: [u8; NOISE_HASHLEN],
     noise_kk_remote_init_h: [u8; NOISE_HASHLEN],
-    was_bob: bool,
 }
 /// `AesGcm` is not threadsafe, but it is threadsafe when inside a `Mutex`.
 unsafe impl<Application: ApplicationLayer> Send for Session<Application> {}

From a7f814e15dab137d800187dcdcbb5e001236775b Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 25 Jul 2023 10:37:40 -0400
Subject: [PATCH 07/50] fixed an old test

---
 src/frag_cache.rs | 28 +++++++++++++++++++---------
 1 file changed, 19 insertions(+), 9 deletions(-)

diff --git a/src/frag_cache.rs b/src/frag_cache.rs
index ebb428e..62ddfc0 100644
--- a/src/frag_cache.rs
+++ b/src/frag_cache.rs
@@ -234,9 +234,20 @@ impl<Fragment> Drop for UnassociatedFragCache<Fragment> {
     }
 }
 
-/*
 #[test]
 fn test_cache() {
+    use std::sync::Mutex;
+    fn xorshift64_random() -> u64 {
+        static XORSHIFT64_STATE: Mutex<u64> = Mutex::new(12);
+        let mut x = XORSHIFT64_STATE.lock().unwrap();
+        *x ^= x.wrapping_shr(12);
+        *x ^= x.wrapping_shl(25);
+        *x ^= x.wrapping_shr(27);
+        let r = *x;
+        drop(x);
+        r.wrapping_mul(0x2545F4914F6CDD1Du64)
+    }
+
     let mut cache = UnassociatedFragCache::new();
     let mut assembled = Assembled::new();
 
@@ -245,8 +256,8 @@ fn test_cache() {
     let mut in_progress_fragments = 0;
     // A basic fuzzer for testing the cache.
     for i in 0..5000u32 {
-        let fragment_count = (random::xorshift64_random() as usize % MAX_FRAGMENTS) + 1;
-        let r = random::xorshift64_random() as u8;
+        let fragment_count = (xorshift64_random() as usize % MAX_FRAGMENTS) + 1;
+        let r = xorshift64_random() as u8;
         if r & 1 == 0 {
             let mut packet = Vec::new();
             for j in 0..fragment_count {
@@ -256,7 +267,7 @@ fn test_cache() {
             in_progress.push((i, fragment_count as u8, packet));
         } else {
             assembled.empty();
-            let drop = random::xorshift64_random() as usize % (2 * fragment_count);
+            let drop = xorshift64_random() as usize % (2 * fragment_count);
             for j in 0..fragment_count {
                 if drop != j {
                     let fragment = vec![0, 1, 2, 3, 4, 5, 6, r];
@@ -279,11 +290,11 @@ fn test_cache() {
         }
         if r > 200 {
             if in_progress.len() > 0 {
-                let to_remain = (random::xorshift64_random() as usize % in_progress_fragments) + 16;
+                let to_remain = (xorshift64_random() as usize % in_progress_fragments) + 16;
                 while in_progress_fragments > to_remain {
-                    let (id, fragment_count, mut packet) = in_progress.swap_remove(random::xorshift64_random() as usize % in_progress.len());
-                    for _ in 0..((random::xorshift64_random() as usize % packet.len()) + 1) {
-                        let (no, fragment) = packet.swap_remove(random::xorshift64_random() as usize % packet.len());
+                    let (id, fragment_count, mut packet) = in_progress.swap_remove(xorshift64_random() as usize % in_progress.len());
+                    for _ in 0..((xorshift64_random() as usize % packet.len()) + 1) {
+                        let (no, fragment) = packet.swap_remove(xorshift64_random() as usize % packet.len());
 
                         assembled.empty();
                         let mut nonce = [0; 10];
@@ -304,4 +315,3 @@ fn test_cache() {
         }
     }
 }
- */

From 0ea6935b6e715c0dcf8e59e6bc9ec6d020ebf9a4 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 25 Jul 2023 11:33:27 -0400
Subject: [PATCH 08/50] switched to try_into syntax

---
 src/zssp.rs | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/zssp.rs b/src/zssp.rs
index 366307f..77b4f9f 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -628,8 +628,7 @@ impl<Application: ApplicationLayer> Context<Application> {
         let mut assembled_packet = Assembled::new(); // needs to outlive the block below
         let mut incoming = None;
         let (session, packet_type, fragments) = {
-            let mut local_key_id = [0u8; SESSION_ID_SIZE];
-            local_key_id.copy_from_slice(&incoming_physical_packet[0..SESSION_ID_SIZE]);
+            let local_key_id = incoming_physical_packet[0..SESSION_ID_SIZE].try_into().unwrap();
             // `from_ne_bytes` because this id was generated locally.
             if let Some(local_key_id) = NonZeroU32::new(u32::from_ne_bytes(local_key_id)) {
                 let session_map = self.0.session_map.read().unwrap();
@@ -902,9 +901,7 @@ impl<Application: ApplicationLayer> Context<Application> {
                         IncomingSessionAction::Allow => {}
                         IncomingSessionAction::Challenge => {
                             let response: &ChallengeResponse = byte_array_as_proto_buffer(&message[p_auth_end..message_size]);
-                            let mut counter = 0u64.to_ne_bytes();
-                            counter.copy_from_slice(&response.challenge_counter);
-                            let counter = u64::from_be_bytes(counter);
+                            let counter = u64::from_be_bytes(response.challenge_counter.try_into().unwrap());
 
                             sha512.reset();
                             let mut hasher = ShaHasher(sha512);
@@ -2572,10 +2569,8 @@ fn create_message_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE]
 /// returns `(fragment_count, fragment_no, packet_type, counter, header_nonce)`.
 #[inline(always)]
 fn parse_packet_header(packet: &[u8]) -> (u8, u8, u8, u64, [u8; 10]) {
-    let mut header_nonce = [0; 10];
-    let mut counter = 0u64.to_ne_bytes();
-    header_nonce.copy_from_slice(&packet[6..16]);
-    counter.copy_from_slice(&packet[8..16]);
+    let header_nonce = packet[6..16].try_into().unwrap();
+    let counter = packet[8..16].try_into().unwrap();
     // We intentionally ignore the version number for future revisions.
     (packet[4], packet[5], packet[7], u64::from_be_bytes(counter), header_nonce)
 }

From e137ecc209ff254c08276abc36edfeb2a80904a6 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 25 Jul 2023 11:34:19 -0400
Subject: [PATCH 09/50] added volatile write destruction

---
 src/crypto/secret.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/crypto/secret.rs b/src/crypto/secret.rs
index 60399b3..461470f 100644
--- a/src/crypto/secret.rs
+++ b/src/crypto/secret.rs
@@ -1,5 +1,5 @@
 // (c) 2020-2022 ZeroTier, Inc. -- currently proprietary pending actual release and licensing. See LICENSE.md.
-use std::convert::TryInto;
+use std::{convert::TryInto, ptr::write_volatile};
 
 /// Constant time byte slice equality.
 #[inline]
@@ -88,14 +88,18 @@ impl<const L: usize> Secret<L> {
 
 impl<const L: usize> Drop for Secret<L> {
     fn drop(&mut self) {
-        self.0.fill(0);
+        unsafe {
+            for v in self.0.iter_mut() {
+                write_volatile(v, 0u8);
+            }
+        }
     }
 }
 
 impl<const L: usize> Default for Secret<L> {
     #[inline(always)]
     fn default() -> Self {
-        Self([0_u8; L])
+        Self([0u8; L])
     }
 }
 

From 4a038f4e2c5ae2bf17d8b85704bf388f9e1d0bbb Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 25 Jul 2023 11:34:29 -0400
Subject: [PATCH 10/50] added docs

---
 src/crypto/aes_gcm.rs | 16 ++++++++++++++++
 src/crypto/p384.rs    | 16 +++++++++++++++-
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/src/crypto/aes_gcm.rs b/src/crypto/aes_gcm.rs
index 250c587..303280e 100644
--- a/src/crypto/aes_gcm.rs
+++ b/src/crypto/aes_gcm.rs
@@ -4,6 +4,14 @@ pub const AES_GCM_TAG_SIZE: usize = 16;
 pub const AES_GCM_IV_SIZE: usize = 12;
 pub const AES_GCM_KEY_SIZE: usize = super::aes::AES_256_KEY_SIZE;
 
+/// The order of calls to this trait is always
+/// `set_iv` -> `set_aad` -> `encrypt` -> `finish_encrypt`.
+/// `set_aad` and `encrypt` may not always be called. `encrypt_in_place` may be called instead of
+/// `encrypt`. `encrypt` may be called multiple times, it should start encryption of the input at the point in
+/// the keystream where encryption previously ended.
+/// An instance of this trait may be reused multiple times, each reuse should use the same key.
+/// If it is reused, `set_iv` will always be the very next call after `finish_encrypt`.
+///
 /// Implementations of this trait does not have to be Send + Sync,
 /// but if it is wrapped in a `Mutex` it must satisfy the requirements of Send + Sync.
 pub trait AesGcmEnc {
@@ -20,6 +28,14 @@ pub trait AesGcmEnc {
     fn finish_encrypt(&mut self, output: &mut [u8; AES_GCM_TAG_SIZE]);
 }
 
+/// The order of calls to this trait is always
+/// `set_iv` -> `set_aad` -> `decrypt` -> `finish_decrypt`.
+/// `set_aad` and `decrypt` may not always be called. `decrypt_in_place` may be called instead of
+/// `decrypt`. `decrypt` may be called multiple times, it should start decryption of the input at the point in
+/// the keystream where decryption previously ended.
+/// An instance of this trait may be reused multiple times, each reuse should use the same key.
+/// If it is reused, `set_iv` will always be the very next call after `finish_decrypt`.
+///
 /// Implementations of this trait does not have to be Send + Sync,
 /// but if it is wrapped in a `Mutex` it must satisfy the requirements of Send + Sync.
 pub trait AesGcmDec {
diff --git a/src/crypto/p384.rs b/src/crypto/p384.rs
index 2a14067..f524972 100644
--- a/src/crypto/p384.rs
+++ b/src/crypto/p384.rs
@@ -8,9 +8,14 @@ pub const P384_ECDH_SHARED_SECRET_SIZE: usize = 48;
 /// A NIST P-384 ECDH/ECDSA public key.
 pub trait P384PublicKey: Sized + Send + Sync {
     /// Create a p384 public key from raw bytes.
+    ///
+    /// **CRITICAL**: This function must return `None` if the input `raw_key` is not on the P384 curve,
+    /// or if it breaks the P384 standard in any other way.
     fn from_bytes(raw_key: &[u8; P384_PUBLIC_KEY_SIZE]) -> Option<Self>;
 
     /// Get the raw bytes that uniquely define the public key.
+    ///
+    /// This must output the standard 49 byte NIST encoding of P384 public keys.
     fn as_bytes(&self) -> &[u8; P384_PUBLIC_KEY_SIZE];
 }
 
@@ -24,8 +29,17 @@ pub trait P384KeyPair: Send + Sync {
     fn generate(rng: &mut Self::Rng) -> Self;
 
     /// Get the raw bytes that uniquely define the public key.
+    ///
+    /// This must output the standard 49 byte NIST encoding of P384 public keys.
     fn public_key_bytes(&self) -> &[u8; P384_PUBLIC_KEY_SIZE];
 
-    /// Perform ECDH key agreement, returning the raw (un-hashed!) ECDH secret.
+    /// Perform ECDH key agreement, writing the raw (un-hashed!) ECDH secret to `output`.
+    ///
+    /// **CRITICAL**: This function must return `false` if key agreement between this private key and
+    /// the input `other_public` key would result in an invalid, non-standard or predictable ECDH secret.
+    /// Please refer to the NIST spec for P384 ECDH key agreement, or better yet use a peer reviewed
+    /// library that has already implemented this correctly.
+    ///
+    /// If this function returns `false` then the contents of `output` will be discarded.
     fn agree(&self, other_public: &Self::PublicKey, output: &mut [u8; P384_ECDH_SHARED_SECRET_SIZE]) -> bool;
 }

From 8b1105f36f14a3fc9331b57223651639c581673d Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 25 Jul 2023 12:00:41 -0400
Subject: [PATCH 11/50] added docs

---
 src/crypto/aes.rs     | 18 ++++++++++++++++++
 src/crypto/aes_gcm.rs | 12 ++++++++----
 src/crypto/p384.rs    |  2 ++
 3 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index 842e1ed..637d009 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -3,18 +3,36 @@
 pub const AES_256_BLOCK_SIZE: usize = 16;
 pub const AES_256_KEY_SIZE: usize = 32;
 
+/// A trait for encrypting individual blocks of plaintext using AES-256.
+/// It is used for header authentication, for which we have a standard model proof that our
+/// algorithm is secure.
+///
+/// Instances must securely delete their keys when dropped or reset.
 pub trait AesEnc: Send + Sync {
     fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self;
 
+    /// Change the encryption key to `key` so that all future encryption is performed with it.
+    /// This function is very rarely called so it does not have to be particularly efficient.
     fn reset(&self, key: &[u8; AES_256_KEY_SIZE]);
 
+    /// Decrypt the given `block` of plaintext directly using the AES block cipher
+    /// (i.e. AES-256 in zero-padding ECB mode).
+    /// The ciphertext should be written directly back out to `block`.
     fn encrypt_in_place(&self, block: &mut [u8; AES_256_BLOCK_SIZE]);
 }
 
+/// A trait for decrypting individual blocks of plaintext using AES-256.
+///
+/// Instances must securely delete their keys when dropped or reset.
 pub trait AesDec: Send + Sync {
     fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self;
 
+    /// Change the decryption key to `key` so that all future decryption is performed with it.
+    /// This function is very rarely called so it does not have to be particularly efficient.
     fn reset(&self, key: &[u8; AES_256_KEY_SIZE]);
 
+    /// Decrypt the given `block` of ciphertext directly using the AES 256 block cipher
+    /// (i.e. AES-256 in zero-padding ECB mode).
+    /// The plaintext should be written directly back out to `block`.
     fn decrypt_in_place(&self, block: &mut [u8; AES_256_BLOCK_SIZE]);
 }
diff --git a/src/crypto/aes_gcm.rs b/src/crypto/aes_gcm.rs
index 303280e..c8328ed 100644
--- a/src/crypto/aes_gcm.rs
+++ b/src/crypto/aes_gcm.rs
@@ -12,8 +12,10 @@ pub const AES_GCM_KEY_SIZE: usize = super::aes::AES_256_KEY_SIZE;
 /// An instance of this trait may be reused multiple times, each reuse should use the same key.
 /// If it is reused, `set_iv` will always be the very next call after `finish_encrypt`.
 ///
-/// Implementations of this trait does not have to be Send + Sync,
-/// but if it is wrapped in a `Mutex` it must satisfy the requirements of Send + Sync.
+/// Implementations of this trait do not have to be Send + Sync,
+/// but if instances are wrapped in a `Mutex` they must satisfy the requirements of Send + Sync.
+///
+/// Instances must securely delete their keys when dropped.
 pub trait AesGcmEnc {
     fn new(key: &[u8; AES_GCM_KEY_SIZE]) -> Self;
 
@@ -36,8 +38,10 @@ pub trait AesGcmEnc {
 /// An instance of this trait may be reused multiple times, each reuse should use the same key.
 /// If it is reused, `set_iv` will always be the very next call after `finish_decrypt`.
 ///
-/// Implementations of this trait does not have to be Send + Sync,
-/// but if it is wrapped in a `Mutex` it must satisfy the requirements of Send + Sync.
+/// Implementations of this trait do not have to be Send + Sync,
+/// but if instances are wrapped in a `Mutex` they must satisfy the requirements of Send + Sync.
+///
+/// Instances must securely delete their keys when dropped.
 pub trait AesGcmDec {
     fn new(key: &[u8; AES_GCM_KEY_SIZE]) -> Self;
 
diff --git a/src/crypto/p384.rs b/src/crypto/p384.rs
index f524972..d340356 100644
--- a/src/crypto/p384.rs
+++ b/src/crypto/p384.rs
@@ -20,6 +20,8 @@ pub trait P384PublicKey: Sized + Send + Sync {
 }
 
 /// A NIST P-384 ECDH/ECDSA public/private key pair.
+///
+/// Instances must securely delete the private key when dropped.
 pub trait P384KeyPair: Send + Sync {
     type PublicKey: P384PublicKey;
     type Rng: RngCore + CryptoRng;

From 4e7e33b468eeb0b42b77f256935badc170533934 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 25 Jul 2023 12:23:53 -0400
Subject: [PATCH 12/50] removed inline

---
 src/applicationlayer.rs |  1 -
 src/fragged.rs          |  6 ------
 src/indexed_heap.rs     |  1 -
 src/ratchet_state.rs    |  8 --------
 src/symmetric_state.rs  |  5 -----
 src/zssp.rs             | 29 -----------------------------
 6 files changed, 50 deletions(-)

diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 0485f7f..ff0a957 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -191,6 +191,5 @@ pub trait ApplicationLayer: Sized {
     ) -> Result<(), Self::IoError>;
 
     #[allow(unused)]
-    #[inline]
     fn event_log(&self, event: LogEvent<Self>, current_time: i64) {}
 }
diff --git a/src/fragged.rs b/src/fragged.rs
index a9eb2cc..77ee095 100644
--- a/src/fragged.rs
+++ b/src/fragged.rs
@@ -30,13 +30,11 @@ impl<Fragment> Assembled<Fragment> {
     }
 }
 impl<Fragment> AsRef<[Fragment]> for Assembled<Fragment> {
-    #[inline(always)]
     fn as_ref(&self) -> &[Fragment] {
         unsafe { &*slice_from_raw_parts(self.0.as_ptr().cast::<Fragment>(), self.1) }
     }
 }
 impl<Fragment> Drop for Assembled<Fragment> {
-    #[inline(always)]
     fn drop(&mut self) {
         self.empty()
     }
@@ -52,7 +50,6 @@ pub struct Fragged<Fragment, const MAX_FRAGMENTS: usize> {
 }
 
 impl<Fragment, const MAX_FRAGMENTS: usize> Fragged<Fragment, MAX_FRAGMENTS> {
-    #[inline(always)]
     pub fn new() -> Self {
         debug_assert!(MAX_FRAGMENTS <= 64);
         unsafe { zeroed() }
@@ -64,7 +61,6 @@ impl<Fragment, const MAX_FRAGMENTS: usize> Fragged<Fragment, MAX_FRAGMENTS> {
     /// be reused to assemble another packet.
     ///
     /// Will check that aad is the same for all fragments.
-    #[inline]
     pub(crate) fn assemble(
         &mut self,
         nonce: [u8; 10],
@@ -107,7 +103,6 @@ impl<Fragment, const MAX_FRAGMENTS: usize> Fragged<Fragment, MAX_FRAGMENTS> {
     }
 
     /// Drops any remaining fragments and resets this object.
-    #[inline(always)]
     pub fn drop_in_place(&mut self) {
         if needs_drop::<Fragment>() {
             let mut have = self.have;
@@ -129,7 +124,6 @@ impl<Fragment, const MAX_FRAGMENTS: usize> Fragged<Fragment, MAX_FRAGMENTS> {
 }
 
 impl<Fragment, const MAX_FRAGMENTS: usize> Drop for Fragged<Fragment, MAX_FRAGMENTS> {
-    #[inline(always)]
     fn drop(&mut self) {
         self.drop_in_place();
     }
diff --git a/src/indexed_heap.rs b/src/indexed_heap.rs
index 8a0547c..70085dc 100644
--- a/src/indexed_heap.rs
+++ b/src/indexed_heap.rs
@@ -42,7 +42,6 @@ impl<T, P: Ord> IndexedBinaryHeap<T, P> {
             .first_mut()
             .map(|entry| (&mut entry.0, &entry.1, BinaryHeapIndex(entry.2, self.map[entry.2].1)))
     }
-    #[inline]
     fn swap(&mut self, a: usize, b: usize) {
         self.map[self.data[a].2].0 = b;
         self.map[self.data[b].2].0 = a;
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index fddbc57..273a358 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -19,38 +19,30 @@ pub enum RatchetState {
 }
 use RatchetState::*;
 impl RatchetState {
-    #[inline]
     pub fn new_nonempty(key: Secret<RATCHET_SIZE>, fingerprint: Secret<RATCHET_SIZE>, chain_len: NonZeroU64) -> Self {
         NonEmpty(NonEmptyRatchetState { key, fingerprint, chain_len })
     }
-    #[inline]
     pub fn new_initial_states() -> [RatchetState; 2] {
         [RatchetState::Empty, RatchetState::Null]
     }
-    #[inline]
     pub fn is_null(&self) -> bool {
         matches!(self, Null)
     }
-    #[inline]
     pub fn is_empty(&self) -> bool {
         matches!(self, Empty)
     }
-    #[inline]
     pub fn nonempty(&self) -> Option<&NonEmptyRatchetState> {
         match self {
             NonEmpty(rs) => Some(rs),
             _ => None,
         }
     }
-    #[inline]
     pub fn chain_len(&self) -> u64 {
         self.nonempty().map_or(0, |rs| rs.chain_len.get())
     }
-    #[inline]
     pub fn fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
         self.nonempty().map(|rs| rs.fingerprint.as_ref())
     }
-    #[inline]
     pub fn key(&self) -> Option<&[u8; RATCHET_SIZE]> {
         const ZERO_KEY: [u8; RATCHET_SIZE] = [0u8; RATCHET_SIZE];
         match self {
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 6f6ac6f..e6e5e52 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -33,7 +33,6 @@ impl SymmetricState {
         // `InitializeKey` would be completely pointless.
     }
     /// Corresponds to Noise `MixKey` followed by `InitializeKey`.
-    #[inline(always)]
     pub(crate) fn mix_key_initialize_key(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) -> Secret<AES_256_KEY_SIZE> {
         let mut next_ck = Secret::new();
         let mut temp_k = [0u8; NOISE_HASHLEN];
@@ -83,7 +82,6 @@ impl SymmetricState {
     /// is forward secrect and is cryptographically independent from all other produced keys.
     /// Based on Noise's unstable ASK mechanism, using KBKDF instead of HKDF.
     /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
-    #[inline(always)]
     pub(crate) fn get_ask2(
         &self,
         hm: &mut impl HmacSha512,
@@ -99,7 +97,6 @@ impl SymmetricState {
         )
     }
     /// Corresponds to Noise `Split`.
-    #[inline(always)]
     pub(crate) fn split(self, hm: &mut impl HmacSha512) -> (Secret<AES_256_KEY_SIZE>, Secret<AES_256_KEY_SIZE>) {
         let mut temp_k1 = [0u8; NOISE_HASHLEN];
         let mut temp_k2 = [0u8; NOISE_HASHLEN];
@@ -111,7 +108,6 @@ impl SymmetricState {
             Secret::from_bytes_then_delete(&mut temp_k2[..AES_256_KEY_SIZE]),
         )
     }
-    #[inline(always)]
     fn label(&self) -> [u8; 4] {
         [b'Z', b'S', b'S', self.token_counter]
     }
@@ -126,7 +122,6 @@ impl SymmetricState {
     /// * L = `num_outputs*512u16`
     /// We have intentionally made every input small and fixed size to avoid unnecessary complexity
     /// and data representation ambiguity.
-    #[inline(always)]
     fn kbkdf(
         &self,
         hm: &mut impl HmacSha512,
diff --git a/src/zssp.rs b/src/zssp.rs
index 77b4f9f..98f9a3f 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -292,7 +292,6 @@ impl<Application: ApplicationLayer> Context<Application> {
     ///   with remote peers (although both of these properties would help reliability slightly).
     ///   Used to determine if any current handshakes should be resent or timed-out, or if a session
     ///   should rekey.
-    #[inline]
     pub fn service<SendFn: FnMut(&mut [u8]) -> bool>(
         &self,
         app: &Application,
@@ -471,7 +470,6 @@ impl<Application: ApplicationLayer> Context<Application> {
     ///   for the upper protocol to authenticate and approve of Alice's identity.
     /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
     /// with the remote peer. Used to determine when this offer should be resent.
-    #[inline]
     pub fn open(
         &self,
         app: &Application,
@@ -600,7 +598,6 @@ impl<Application: ApplicationLayer> Context<Application> {
     /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
     ///   with the remote peer. Used to check the state of local offers we may currently have or want
     ///   to put in-flight.
-    #[inline]
     pub fn receive<'a, SendFn: FnMut(&mut [u8]) -> bool>(
         &self,
         app: &Application,
@@ -1648,7 +1645,6 @@ impl<Application: ApplicationLayer> Context<Application> {
     /// * `send` - Function to call to send physical packet(s); the buffer passed to `send` is a
     ///   slice of `data`
     /// * `current_time` - Current time in milliseconds
-    #[inline]
     pub fn send_empty(&self, session: &Arc<Session<Application>>, send: impl FnMut(&mut [u8]) -> bool, current_time: i64) -> Result<(), SendError> {
         self.send(session, send, &mut [0u8; MIN_TRANSPORT_MTU], &[], current_time)
     }
@@ -1660,7 +1656,6 @@ impl<Application: ApplicationLayer> Context<Application> {
     /// * `mtu_sized_buffer` - A writable work buffer whose size equals the MTU
     /// * `data` - Data to send
     /// * `current_time` - Current time in milliseconds
-    #[inline]
     pub fn send(
         &self,
         session: &Arc<Session<Application>>,
@@ -1730,7 +1725,6 @@ impl<Application: ApplicationLayer> Context<Application> {
         Ok(())
     }
     /// Update the challenge window, returning true if the challenge is still valid.
-    #[inline(always)]
     fn check_challenge_window(&self, counter: u64) -> bool {
         let slot = &self.0.challenge_antireplay_window[(counter as usize) % self.0.challenge_antireplay_window.len()];
         let counter = counter.wrapping_add(1);
@@ -1738,7 +1732,6 @@ impl<Application: ApplicationLayer> Context<Application> {
         prev_counter < counter
     }
     /// Update the challenge window, returning true if the challenge is still valid.
-    #[inline(always)]
     fn update_challenge_window(&self, counter: u64) -> bool {
         let slot = &self.0.challenge_antireplay_window[(counter as usize) % self.0.challenge_antireplay_window.len()];
         let counter = counter.wrapping_add(1);
@@ -2188,7 +2181,6 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
 
 impl<Application: ApplicationLayer> Session<Application> {
     /// This can only fail with `MaxKeyLifetimeExceeded` or `SessionNotEstablished`.
-    #[inline]
     fn send_control(
         &self,
         state: &SessionMutableState<Application>,
@@ -2211,25 +2203,21 @@ impl<Application: ApplicationLayer> Session<Application> {
         Ok(())
     }
     /// Check whether this session is established.
-    #[inline]
     pub fn established(&self) -> bool {
         let state = self.state.read().unwrap();
         !matches!(&state.outgoing_offer, OfferStateMachine::NoiseXKPattern1or3(_) | OfferStateMachine::Null)
     }
     /// The static public key of the remote peer.
-    #[inline]
     pub fn remote_s_public_key(&self) -> &Application::PublicKey {
         &self.remote_static_key
     }
     /// The current ratchet state of this session.
     /// The returned values are sensitive and should be securely erased before being dropped.
-    #[inline]
     pub fn ratchet_states(&self) -> [RatchetState; 2] {
         let state = self.state.read().unwrap();
         state.ratchet_states.clone()
     }
     /// The current ratchet count of this session.
-    #[inline]
     pub fn ratchet_count(&self) -> u64 {
         self.state.read().unwrap().ratchet_states[0].chain_len()
     }
@@ -2267,7 +2255,6 @@ impl<Application: ApplicationLayer> Session<Application> {
     }
 
     /// Get the next outgoing counter value.
-    #[inline(always)]
     fn get_next_outgoing_counter(&self) -> Result<u64, SendError> {
         if self.session_has_expired.load(Ordering::Relaxed) {
             Err(SendError::SessionExpired)
@@ -2283,7 +2270,6 @@ impl<Application: ApplicationLayer> Session<Application> {
         }
     }
     /// Check the receive window without mutating state.
-    #[inline(always)]
     fn check_receive_window(&self, counter: u64) -> bool {
         let slot = &self.counter_antireplay_window[(counter as usize) % self.counter_antireplay_window.len()];
         let counter = counter.wrapping_add(1);
@@ -2292,7 +2278,6 @@ impl<Application: ApplicationLayer> Session<Application> {
     }
     /// Update the receive window, returning true if the packet is still valid.
     /// This should only be called after the packet is authenticated.
-    #[inline(always)]
     fn update_receive_window(&self, counter: u64) -> bool {
         let slot = &self.counter_antireplay_window[(counter as usize) % self.counter_antireplay_window.len()];
         let counter = counter.wrapping_add(1);
@@ -2311,7 +2296,6 @@ impl<Application: ApplicationLayer> Drop for Session<Application> {
 impl<Application: ApplicationLayer> NoiseXKAliceHandshake<Application> {
     /// Can only fail with `OpenError::InvalidPublicKey` because of remote_s_public_key.
     /// Corresponds to Noise `Initialize`.
-    #[inline]
     fn initialize(
         local_key_id: NonZeroU32,
         remote_s_public_key: &Application::PublicKey,
@@ -2446,7 +2430,6 @@ fn process_timer(timer: &AtomicI64, wait_time: i64, current_time: i64) -> Option
 }
 
 /// Corresponds to Noise `EncryptAndHash`.
-#[inline]
 fn encrypt_and_hash<Application: ApplicationLayer>(
     sha512: &mut Application::Hash,
     noise_k: &Secret<AES_GCM_KEY_SIZE>,
@@ -2467,7 +2450,6 @@ fn encrypt_and_hash<Application: ApplicationLayer>(
     mix_hash(sha512, noise_h, message)
 }
 /// Corresponds to Noise `DecryptAndHash`.
-#[inline]
 fn decrypt_and_hash<Application: ApplicationLayer>(
     sha512: &mut Application::Hash,
     noise_k: &Secret<AES_GCM_KEY_SIZE>,
@@ -2487,7 +2469,6 @@ fn decrypt_and_hash<Application: ApplicationLayer>(
     (gcm.finish_decrypt((&message[auth_start..]).try_into().unwrap()), noise_h_c)
 }
 /// Encrypt a standardized control packet.
-#[inline]
 fn encrypt_control(
     c: &mut impl AesGcmEnc,
     header_cipher: &impl AesEnc,
@@ -2509,7 +2490,6 @@ fn encrypt_control(
     header_cipher.encrypt_in_place((&mut fragment[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END]).try_into().unwrap());
     (fragment, fragment_len)
 }
-#[inline]
 fn decrypt_control<'a, IoError>(
     c: &mut impl AesGcmDec,
     packet_type: u8,
@@ -2530,7 +2510,6 @@ fn decrypt_control<'a, IoError>(
     Ok(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE])
 }
 
-#[inline(always)]
 fn set_packet_header(packet: &mut [u8], fragment_count: u8, fragment_no: u8, packet_type: u8, remote_key_id: u32, counter_or_id: u64) {
     debug_assert!(packet.len() >= MIN_PACKET_SIZE);
     debug_assert!(fragment_count > 0);
@@ -2558,7 +2537,6 @@ fn set_packet_header(packet: &mut [u8], fragment_count: u8, fragment_no: u8, pac
 /// it as effectively AAD. Other elements of the header are either not authenticated,
 /// like fragmentation info, or their authentication is implied via key exchange like
 /// the key id.
-#[inline(always)]
 fn create_message_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
     let mut ret = [0u8; AES_GCM_IV_SIZE];
     ret[3] = packet_type;
@@ -2567,7 +2545,6 @@ fn create_message_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE]
     ret
 }
 /// returns `(fragment_count, fragment_no, packet_type, counter, header_nonce)`.
-#[inline(always)]
 fn parse_packet_header(packet: &[u8]) -> (u8, u8, u8, u64, [u8; 10]) {
     let header_nonce = packet[6..16].try_into().unwrap();
     let counter = packet[8..16].try_into().unwrap();
@@ -2658,7 +2635,6 @@ fn generate_key_id<Application: ApplicationLayer>(
 }
 
 impl<Application: ApplicationLayer> SessionKey<Application> {
-    #[inline(always)]
     fn new(
         hmac: &mut Application::HmacHash,
         ck: SymmetricState,
@@ -2685,7 +2661,6 @@ impl<Application: ApplicationLayer> SessionKey<Application> {
         }
     }
 
-    #[inline(always)]
     fn get_send_cipher(&self, counter: u64) -> Result<MutexGuard<Application::AeadEnc>, SendError> {
         if counter < self.expire_at_counter {
             Ok(self.send_cipher_pool[(counter as usize) % self.send_cipher_pool.len()].lock().unwrap())
@@ -2694,7 +2669,6 @@ impl<Application: ApplicationLayer> SessionKey<Application> {
         }
     }
 
-    #[inline(always)]
     fn get_receive_cipher(&self, counter: u64) -> MutexGuard<Application::AeadDec> {
         let idx = (counter as usize) % self.receive_cipher_pool.len();
         self.receive_cipher_pool[idx].lock().unwrap()
@@ -2702,7 +2676,6 @@ impl<Application: ApplicationLayer> SessionKey<Application> {
 }
 
 /// MixHash to update 'h' during negotiation.
-#[inline(always)]
 fn mix_hash(hasher: &mut impl Sha512, h: &[u8; NOISE_HASHLEN], m: &[u8]) -> [u8; NOISE_HASHLEN] {
     let mut output = [0u8; NOISE_HASHLEN];
     hasher.reset();
@@ -2713,7 +2686,6 @@ fn mix_hash(hasher: &mut impl Sha512, h: &[u8; NOISE_HASHLEN], m: &[u8]) -> [u8;
 }
 /// Check if the proof of work attached to the first message contains the correct number of leading
 /// zeros.
-#[inline(always)]
 fn verify_pow<Application: ApplicationLayer>(hasher: &mut Application::Hash, response: &[u8]) -> bool {
     if Application::PROOF_OF_WORK_BIT_DIFFICULTY == 0 {
         return true;
@@ -2725,7 +2697,6 @@ fn verify_pow<Application: ApplicationLayer>(hasher: &mut Application::Hash, res
     let n = u32::from_be_bytes(output[..4].try_into().unwrap());
     n.leading_zeros() >= Application::PROOF_OF_WORK_BIT_DIFFICULTY
 }
-#[inline(always)]
 fn from_bytes_agreement<Application: ApplicationLayer>(
     public: &[u8],
     private: &Application::KeyPair,

From a6092a56be576e12b3a330da7f10f713a3cac227 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 25 Jul 2023 12:25:18 -0400
Subject: [PATCH 13/50] removed inline

---
 src/crypto/secret.rs | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/src/crypto/secret.rs b/src/crypto/secret.rs
index 461470f..902eb6d 100644
--- a/src/crypto/secret.rs
+++ b/src/crypto/secret.rs
@@ -2,7 +2,6 @@
 use std::{convert::TryInto, ptr::write_volatile};
 
 /// Constant time byte slice equality.
-#[inline]
 pub fn secure_eq<A: AsRef<[u8]> + ?Sized, B: AsRef<[u8]> + ?Sized>(a: &A, b: &B) -> bool {
     let (a, b) = (a.as_ref(), b.as_ref());
     if a.len() == b.len() {
@@ -31,7 +30,6 @@ pub struct Secret<const L: usize>(pub [u8; L]);
 
 impl<const L: usize> Secret<L> {
     /// Create a new all-zero secret.
-    #[inline(always)]
     pub fn new() -> Self {
         Self([0_u8; L])
     }
@@ -45,30 +43,25 @@ impl<const L: usize> Secret<L> {
     /// This is unsafe because it will not destroy the contents of its input.
     /// # Safety
     /// Make sure the contents of the input are securely deleted.
-    #[inline(always)]
     pub unsafe fn from_bytes(b: &[u8]) -> Self {
         Self(b.try_into().unwrap())
     }
 
-    #[inline(always)]
     pub fn as_ptr(&self) -> *const u8 {
         self.0.as_ptr()
     }
 
-    #[inline(always)]
     pub fn as_bytes(&self) -> &[u8; L] {
         &self.0
     }
 
     /// Get the first N bytes of this secret as a fixed length array.
-    #[inline(always)]
     pub fn first_n<const N: usize>(&self) -> &[u8; N] {
         assert!(N <= L);
         unsafe { &*self.0.as_ptr().cast() }
     }
 
     /// Clone the first N bytes of this secret as another secret.
-    #[inline(always)]
     pub fn first_n_clone<const N: usize>(&self) -> Secret<N> {
         Secret::<N>(*self.first_n())
     }
@@ -97,35 +90,30 @@ impl<const L: usize> Drop for Secret<L> {
 }
 
 impl<const L: usize> Default for Secret<L> {
-    #[inline(always)]
     fn default() -> Self {
         Self([0u8; L])
     }
 }
 
 impl<const L: usize> AsRef<[u8]> for Secret<L> {
-    #[inline(always)]
     fn as_ref(&self) -> &[u8] {
         &self.0
     }
 }
 
 impl<const L: usize> AsRef<[u8; L]> for Secret<L> {
-    #[inline(always)]
     fn as_ref(&self) -> &[u8; L] {
         &self.0
     }
 }
 
 impl<const L: usize> AsMut<[u8]> for Secret<L> {
-    #[inline(always)]
     fn as_mut(&mut self) -> &mut [u8] {
         &mut self.0
     }
 }
 
 impl<const L: usize> AsMut<[u8; L]> for Secret<L> {
-    #[inline(always)]
     fn as_mut(&mut self) -> &mut [u8; L] {
         &mut self.0
     }

From 270e39d1650ff16871aaf659b459928545929b6c Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 25 Jul 2023 12:28:09 -0400
Subject: [PATCH 14/50] reset gitignore

---
 .gitignore | 14 --------------
 Cargo.lock | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 14 deletions(-)
 create mode 100644 Cargo.lock

diff --git a/.gitignore b/.gitignore
index 7dd2bd4..ea8c4bf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,15 +1 @@
 /target
-/**/target
-/**/Cargo.lock
-
-.DS_*
-.Icon*
-._*
-*.o
-*.so
-*.dylib
-*.dSYM
-*.a
-/.idea
-/.nova
-*.secret
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..cd3ec00
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,33 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "hex-literal"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
+
+[[package]]
+name = "pqc_kyber"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84c578a7eab95d8649f115dd6f90894d167766e82a6bcf66ff25f60e7dfc857e"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
+[[package]]
+name = "zssp"
+version = "0.0.3"
+dependencies = [
+ "hex-literal",
+ "pqc_kyber",
+ "rand_core",
+]

From e6df05b6b0faad17812c6da12473b4fe8d8d8d75 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 7 Aug 2023 09:03:55 -0400
Subject: [PATCH 15/50] integrated some files

---
 Cargo.lock                 |   18 +-
 Cargo.toml                 |    3 +-
 src/antireplay.rs          |   24 +
 src/applicationlayer.rs    |  264 ++--
 src/challenge.rs           |  105 ++
 src/context.rs             |  438 ++++++
 src/crypto/aes.rs          |   34 +-
 src/crypto/aes_gcm.rs      |   57 -
 src/crypto/kyber1024.rs    |   36 +
 src/crypto/mod.rs          |   17 +-
 src/crypto/p384.rs         |   43 +-
 src/crypto/secret.rs       |  127 --
 src/crypto/sha512.rs       |   43 +-
 src/lib.rs                 |   23 +-
 src/log_event.rs           |    4 +-
 src/proto.rs               |  303 +---
 src/proto_old.rs           |  296 ++++
 src/ratchet_state.rs       |  130 +-
 src/ratchet_state_old.rs   |   62 +
 src/result.rs              |  162 +++
 src/symmetric_state.rs     |  264 ++--
 src/symmetric_state_old.rs |  156 +++
 src/zeta.rs                | 1394 +++++++++++++++++++
 src/zssp copy.rs           | 2704 ++++++++++++++++++++++++++++++++++++
 src/zssp.rs                |  140 +-
 25 files changed, 6011 insertions(+), 836 deletions(-)
 create mode 100644 src/antireplay.rs
 create mode 100644 src/challenge.rs
 create mode 100644 src/context.rs
 delete mode 100644 src/crypto/aes_gcm.rs
 create mode 100644 src/crypto/kyber1024.rs
 delete mode 100644 src/crypto/secret.rs
 create mode 100644 src/proto_old.rs
 create mode 100644 src/ratchet_state_old.rs
 create mode 100644 src/result.rs
 create mode 100644 src/symmetric_state_old.rs
 create mode 100644 src/zeta.rs
 create mode 100644 src/zssp copy.rs

diff --git a/Cargo.lock b/Cargo.lock
index cd3ec00..e0caaa4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3,10 +3,13 @@
 version = 3
 
 [[package]]
-name = "hex-literal"
-version = "0.4.1"
+name = "arrayvec"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+dependencies = [
+ "zeroize",
+]
 
 [[package]]
 name = "pqc_kyber"
@@ -23,11 +26,18 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 
+[[package]]
+name = "zeroize"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"
+
 [[package]]
 name = "zssp"
 version = "0.0.3"
 dependencies = [
- "hex-literal",
+ "arrayvec",
  "pqc_kyber",
  "rand_core",
+ "zeroize",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 74aa8d5..ca0967b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,4 +13,5 @@ doc = true
 [dependencies]
 pqc_kyber = { version = "0.6.0", default-features = false, features = ["kyber1024", "std"] }
 rand_core = "0.6.4"
-hex-literal = "0.4.1"
+zeroize = { version = "1.6.0" }
+arrayvec = { version = "0.7.4", default-features = false, features = ["std", "zeroize"] }
diff --git a/src/antireplay.rs b/src/antireplay.rs
new file mode 100644
index 0000000..80cd707
--- /dev/null
+++ b/src/antireplay.rs
@@ -0,0 +1,24 @@
+use std::sync::atomic::{AtomicU64, Ordering};
+
+pub struct Window<const L: usize, const MAX: u64> ([AtomicU64; L]);
+
+impl<const L: usize, const MAX: u64> Window<L, MAX> {
+    pub fn new() -> Self {
+        Self(std::array::from_fn(|_| AtomicU64::new(0)))
+    }
+    /// Check the window without mutating state.
+    pub fn check(&self, counter: u64) -> bool {
+        let slot = &self.0[(counter as usize) % self.0.len()];
+        let counter = counter.wrapping_add(1);
+        let prev_counter = slot.load(Ordering::Relaxed);
+        prev_counter < counter && counter.wrapping_sub(prev_counter) <= MAX
+    }
+    /// Update the window, returning true if the packet is still valid.
+    /// This should only be called after the packet is authenticated.
+    pub fn update(&self, counter: u64) -> bool {
+        let slot = &self.0[(counter as usize) % self.0.len()];
+        let counter = counter.wrapping_add(1);
+        let prev_counter = slot.fetch_max(counter, Ordering::Relaxed);
+        prev_counter < counter && counter.wrapping_sub(prev_counter) <= MAX
+    }
+}
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index ff0a957..7f18f60 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
@@ -5,15 +7,89 @@
  * (c) ZeroTier, Inc.
  * https://www.zerotier.com/
  */
-use std::sync::Arc;
-
-use crate::crypto::aes::{AesDec, AesEnc};
-use crate::crypto::aes_gcm::{AesGcmDec, AesGcmEnc};
+use crate::crypto::aes::{AesDec, AesEnc, HighThroughputAesGcmPool, LowThroughputAesGcm};
+use crate::crypto::kyber1024::Kyber1024PrivateKey;
 use crate::crypto::p384::{P384KeyPair, P384PublicKey};
 use crate::crypto::rand_core::{CryptoRng, RngCore};
-use crate::crypto::sha512::{HmacSha512, Sha512};
+use crate::crypto::sha512::{HmacSha512, HashSha512};
 use crate::RatchetState;
-use crate::{log_event::LogEvent, Session, RATCHET_SIZE};
+use crate::proto::RATCHET_SIZE;
+use crate::zssp::Session;
+//use crate::{log_event::LogEvent, Session};
+
+/// A container for a vast majority of the dynamic settings within ZSSP, including all time-based settings.
+/// If the user wishes to measure time in units other than milliseconds for some reason, then they can
+/// create an adjusted version of this struct with those units, and use it instead of the default.
+pub struct Settings {
+    /// Timeout for how long Alice should wait for Bob to confirm that the Noise_XK handshake
+    /// was completed successfully. The handshake attempt will be assumed as failed and
+    /// restarted if Bob does not respond by this cut-off.
+    pub initial_offer_timeout: u64,
+    /// Timeout for how long ZSSP should wait before expiring and closing a session when it has
+    /// lingered in certain states for too long, primarily the rekeying states.
+    /// If a remote peer does not send the correct information to rekey a session before this
+    /// timeout then the session will close.
+    pub rekey_timeout: u64,
+    /// How long until rekeying should occur for each new session key.
+    pub rekey_after_time: u64,
+    /// Maximum random jitter to subtract from the rekey after time timer.
+    /// Must be greater than 0.
+    /// This prevents rekeying from occurring predictably on the hour, so traffic analysis is harder.
+    pub rekey_time_max_jitter: u64,
+    /// How many key uses may occur before the session starts attempting to rekey.
+    /// The session will forceably close at 2^32 key uses so it is recommended this value be smaller.
+    pub rekey_after_key_uses: u64,
+    /// Retry interval for outgoing connection initiation or rekey attempts.
+    ///
+    /// Retry attempts will be no more often than this, but the delay may end up being
+    /// slightly more in some cases based on the rate of calls to `service`.
+    pub resend_time: u64,
+    /// How long fragments are allowed to linger in the defragmentation buffer before they are dropped.
+    /// This implementation of a defrag buffer only bounds memory consumption based on this value.
+    pub fragment_assembly_timeout: u64,
+}
+impl Settings {
+    /// Default value for the `initial_offer_timeout`.
+    /// The default value is 10 seconds in ms.
+    pub const INITIAL_OFFER_TIMEOUT_MS: u64 = 10 * 1000;
+    /// Default value for the `rekey_timeout`.
+    /// The default value is 1 minute in ms.
+    pub const REKEY_TIMEOUT_MS: u64 = 60 * 1000;
+    /// Default value for the `rekey_after_time`.
+    /// The default value is 1 hour in ms.
+    pub const REKEY_AFTER_TIME_MS: u64 = 60 * 60 * 1000;
+    /// Default value for the `rekey_time_max_jitter`.
+    /// The default is 10 minutes in ms.
+    pub const REKEY_AFTER_TIME_MAX_JITTER_MS: u64 = 10 * 60 * 1000;
+    /// Default value for the `rekey_after_key_uses`.
+    /// The default is 2^30.
+    pub const REKEY_AFTER_KEY_USES: u64 = 1 << 30;
+    /// Default value for the `resend_time`.
+    /// The default is 1 second in ms.
+    pub const RESEND_TIME: u64 = 1000;
+    /// Default value for the `fragment_assembly_timeout`.
+    /// The default is 5 seconds in ms.
+    pub const FRAGMENT_ASSEMBLY_TIMEOUT_MS: u64 = 5 * 1000;
+    /// Create an instance of Settings with all default values.
+    /// These defaults are in units of milliseconds, so if these defaults are used, `App::time`
+    /// must return timestamps in unts of milliseconds as well.
+    pub const fn new_ms() -> Self {
+        Self {
+            initial_offer_timeout: Self::INITIAL_OFFER_TIMEOUT_MS,
+            rekey_timeout: Self::REKEY_TIMEOUT_MS,
+            rekey_after_time: Self::REKEY_AFTER_TIME_MS,
+            rekey_time_max_jitter: Self::REKEY_AFTER_TIME_MAX_JITTER_MS,
+            rekey_after_key_uses: Self::REKEY_AFTER_KEY_USES,
+            resend_time: Self::RESEND_TIME,
+            fragment_assembly_timeout: Self::FRAGMENT_ASSEMBLY_TIMEOUT_MS,
+        }
+    }
+}
+impl Default for Settings {
+    fn default() -> Self {
+        Self::new_ms()
+    }
+}
 
 /// Trait to implement to integrate the session into an application.
 ///
@@ -25,84 +101,51 @@ use crate::{log_event::LogEvent, Session, RATCHET_SIZE};
 /// set to the same values. Changing these constants is generally discouraged unless you know
 /// what you are doing.
 pub trait ApplicationLayer: Sized {
-    /// Retry interval for outgoing connection initiation or rekey attempts.
-    ///
-    /// Retry attempts will be no more often than this, but the delay may end up being
-    /// slightly more in some cases depending on where in the cycle the initial attempt
-    /// falls.
-    ///
-    /// Default value is 1 second.
-    const RETRY_INTERVAL_MS: i64 = 1000;
-    /// Timeout for how long Alice should wait for Bob to confirm that the Noise_XK handshake
-    /// was completed successfully. The handshake attempt will be assumed as failed and
-    /// restarted if Bob does not respond by this cut-off.
-    ///
-    /// Default is 10 seconds.
-    const INITIAL_OFFER_TIMEOUT_MS: i64 = 10 * 1000;
-    /// Timeout for how long ZSSP should wait before expiring and closing a session when it has
-    /// lingered in certain states for too long, primarily the rekeying states.
-    /// If a remote peer does not send the correct information to rekey a session before this
-    /// timeout then the session will close.
-    ///
-    /// Default is 1 minute.
-    const EXPIRATION_TIMEOUT_MS: i64 = 60 * 1000;
-    /// Start attempting to rekey after a key has been in use for this many milliseconds.
-    ///
-    /// Default is 1 hour.
-    const REKEY_AFTER_TIME_MS: i64 = 1000 * 60 * 60;
-    /// Maximum random jitter to subtract from the rekey after time timer.
-    /// Must be greater than 0 and less than u32::MAX.
-    /// This prevents rekeying from occurring predictably on the hour, so traffic analysis is harder.
-    ///
-    /// Default is 10 minutes.
-    const REKEY_AFTER_TIME_MAX_JITTER_MS: i64 = 1000 * 60 * 10;
-    /// Rekey after this many key uses.
-    ///
-    /// The default is 1/4 the recommended NIST limit for AES-GCM. Unless you are transferring
-    /// a massive amount of data REKEY_AFTER_TIME_MS is probably going to kick in first.
-    const REKEY_AFTER_USES: u64 = 1073741824;
-
-    /// Hard expiration of a key after this many uses.
-    ///
-    /// Attempting to encrypt more than this many messages with a key will cause a hard error
-    /// and prevent all encryption.
-    /// This should basically never occur in practice because of rekeying.
-    ///
-    /// Default value is 2^32 - 1, one less than NIST's recommended limit.
-    /// https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
-    const EXPIRE_AFTER_USES: u64 = 4294967295;
-
-    /// Determines how computationally difficult the proof of work is when Bob challenges Alice.
-    /// It is extremely computationally expensive on Bob to process Alice's initiation packet. So
-    /// Bob has the option to challenge Alice to prove ownership of address and to prove work before
-    /// they attempt process Alice's initiation packet.
-    /// The amount of computational work Alice has to prove increases exponentially with this value.
-    ///
-    /// This value must be between 0 and 32 (inclusive).
-    ///
-    /// Default is 13, which, on a modern processor, ensures Alice will have to do about as much
-    /// computational work as Bob will when they process Alice's initiation packet.
-    const PROOF_OF_WORK_BIT_DIFFICULTY: u32 = 13;
+    /// These are constants that can be redefined from their defaults to change rekey
+    /// and negotiation timeout behavior. If two sides of a ZSSP session have different constants,
+    /// the protocol will tend to default to the smaller constants.
+    const SETTINGS: Settings = Settings::new_ms();
 
     type Rng: CryptoRng + RngCore;
 
+    /// The implementation of AES-256 Encryption that ZSSP should use.
+    ///
+    /// FIPS compliance requires use of a FIPS certified implementation.
     type PrpEnc: AesEnc;
+    /// The implementation of AES-256 Decryption that ZSSP should use.
+    ///
+    /// FIPS compliance requires use of a FIPS certified implementation.
     type PrpDec: AesDec;
 
-    type AeadEnc: AesGcmEnc;
-    type AeadDec: AesGcmDec;
+    type Aead: LowThroughputAesGcm;
+    type AeadPool: HighThroughputAesGcmPool;
 
-    type Hash: Sha512;
+    /// The implementation of SHA-512 that ZSSP should use.
+    ///
+    /// FIPS compliance requires use of a FIPS certified implementation.
+    type Hash: HashSha512;
     type HmacHash: HmacSha512;
-
+    /// The implementation of P-384 public keys that ZSSP should use.
+    ///
+    /// FIPS compliance requires a FIPS certified implementation.
     type PublicKey: P384PublicKey;
-    type KeyPair: P384KeyPair<PublicKey = Self::PublicKey, Rng = Self::Rng>;
+    /// The implementation of P-384 private keys that ZSSP should use.
+    ///
+    /// FIPS compliance requires use of a FIPS certified implementation.
+    type KeyPair: P384KeyPair<Self::Rng, PublicKey = Self::PublicKey>;
+    /// The implementation of Kyber1024 that ZSSP should use.
+    ///
+    /// No implementation of Kyber1024 can be FIPS certified, but this is not required
+    /// for ZSSP to achieve FIPS compliance.
+    type Kem: Kyber1024PrivateKey<Self::Rng>;
 
-    type IoError: std::fmt::Debug;
+    /// A user-defined error returned when the `ApplicationLayer` fails to access persistent storage
+    /// for a peer's ratchet states.
+    type StorageError: std::error::Error;
 
     /// Type for arbitrary opaque object for use by the application that is attached to
     /// each session.
-    type Data;
+    type SessionData;
 
     /// Data type for incoming packet buffers.
     ///
@@ -116,6 +159,12 @@ pub trait ApplicationLayer: Sized {
     /// It will be dropped as soon as the session is established.
     type LocalIdentityBlob: AsRef<[u8]>;
 
+    /// Should return the current time in milliseconds. Does not have to be monotonic, nor synced
+    /// with remote peers (although both of these properties would help reliability slightly).
+    /// Used to determine if any current handshakes should be resent or timed-out, or if a session
+    /// should rekey.
+    fn time(&self) -> i64;
+
     /// This function will be called whenever Alice's initial Hello packet contains the empty ratchet
     /// fingerprint. Brand new peers will always connect to Bob with the empty ratchet, but from
     /// then on they should be using non-empty ratchet states.
@@ -125,7 +174,7 @@ pub trait ApplicationLayer: Sized {
     /// If this function is configured to always return true, it means peers will not be able to
     /// connect to us unless they had a prior-established ratchet key with us. This is the best way
     /// for the paranoid to enforce a manual allow-list.
-    fn hello_requires_recognized_ratchet(&self, current_time: i64) -> bool;
+    fn hello_requires_recognized_ratchet(&self) -> bool;
     /// This function is called if we, as Alice, attempted to open a session with Bob using a
     /// non-empty ratchet key, but Bob does not have this ratchet key and wants to downgrade
     /// to the zero ratchet key.
@@ -141,7 +190,14 @@ pub trait ApplicationLayer: Sized {
     /// least one party is misconfigured and got their ratchet keys corrupted or lost, or Bob has
     /// been compromised and is being impersonated. An attacker must at least have Bob's private
     /// static key to be able to ask Alice to downgrade.
-    fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>, current_time: i64) -> bool;
+    fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>) -> bool;
+    /// Function to accept sessions after final negotiation.
+    /// The second argument is the identity that the remote peer sent us. The application
+    /// must verify this identity is associated with the remote peer's static key.
+    /// To prevent desync, if this function returns (Some(_), _), no other open session with the
+    /// same remote peer must exist. Drop or call expire on any pre-existing sessions before returning.
+    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self>;
+
     /// Lookup a specific ratchet state based on its ratchet fingerprint.
     /// This function will be called whenever Alice attempts to connect to us with a non-empty
     /// ratchet fingerprint.
@@ -154,19 +210,36 @@ pub trait ApplicationLayer: Sized {
     /// If `RatchetAction::DowngradeRatchet` is returned we will attempt to convince Alice to downgrade
     /// to the empty ratchet key, restarting the ratchet chain.
     /// If `RatchetAction::FailAuthentication` is returned Alice's connection will be silently dropped.
-    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE], current_time: i64) -> Result<RatchetState, Self::IoError>;
-
-    /// Lookup a specific ratchet state based on the identity of the peer being communicated with.
+    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::StorageError>;
+    /// Lookup the specific ratchet states based on the identity of the peer being communicated with.
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
+    ///
+    /// If the peer's ratchet states could not be could, this function should return
+    /// `RatchetState::new_initial_states()`.
+    ///
+    /// If a one-time-password has been pre-shared with this peer, `RatchetState::new_otp_states(...)`
+    /// should be pre-saved to the storage backend as if it is a normal ratchet state.
+    /// This is to ensure it can both be restored and eventually deleted when it is used.
+    ///
+    /// This function is not responsible for deciding whether or not to connect to this remote peer.
+    /// Filtering peers should be done by the caller to `Context::open` as well as by the
+    /// function `ApplicationLayer::check_accept_session`.
     fn restore_by_identity(
         &self,
         remote_static_key: &Self::PublicKey,
-        application_data: &Self::Data,
-        current_time: i64,
-    ) -> Result<[RatchetState; 2], Self::IoError>;
-    /// Atomically save the given `new_ratchet_states` to persistent storage.
-    /// `pre_ratchet_states` contains what should be the previous contents of persistent storage.
+        session_data: &Self::SessionData,
+    ) -> Result<(RatchetState, Option<RatchetState>), Self::StorageError>;
+    /// Atomically save `current_state1` and `current_state2` so that them and only them can be
+    /// restored with `restore_by_identity` and `restore_by_fingerprint` through a system restart.
+    /// Theses should overwrite the previous ratchet states 1 and 2 saved to storage.
+    ///
+    /// `state_added` will be equal to the brand new ratchet state that was added in this update,
+    /// or `None` if there is not a new ratchet state this update. `state_deleted1` and
+    /// `state_deleted2` will be equal to any ratchet states that are to be deleted and overwritten
+    /// as a result of this update, or `None` if there is not one to be deleted.
+    /// `state_added` will always have a non-empty (`Some()`) ratchet fingerprint, and it will
+    /// always be equal to `current_state1`.
     ///
     /// If this returns `Err(IoError)`, the packet which triggered this function to be called will be
     /// dropped, and no session state will be mutated, preserving synchronization. The remote peer
@@ -184,12 +257,27 @@ pub trait ApplicationLayer: Sized {
     fn save_ratchet_state(
         &self,
         remote_static_key: &Self::PublicKey,
-        application_data: &Self::Data,
-        pre_ratchet_states: [&RatchetState; 2],
-        new_ratchet_states: [&RatchetState; 2],
-        current_time: i64,
-    ) -> Result<(), Self::IoError>;
+        session_data: &Self::SessionData,
+        update_data: RatchetUpdate<'_>,
+    ) -> Result<(), Self::StorageError>;
 
-    #[allow(unused)]
-    fn event_log(&self, event: LogEvent<Self>, current_time: i64) {}
+    /// Receives a stream of events that occur during an execution of ZSSP.
+    /// These are provided for debugging, logging or metrics purposes, and must be used for
+    /// nothing else. Do not base protocol-level decisions upon the events passed to this function.
+    #[cfg(feature = "logging")]
+    fn event_log(&self, event: LogEvent<'_, Self>);
+}
+
+pub struct RatchetUpdate<'a> {
+    pub state1: &'a RatchetState,
+    pub state2: Option<&'a RatchetState>,
+    pub state1_was_just_added: bool,
+    pub state_deleted1: Option<&'a RatchetState>,
+    pub state_deleted2: Option<&'a RatchetState>,
+}
+
+pub struct AcceptAction<App: ApplicationLayer> {
+    pub session_data: Option<App::SessionData>,
+    pub responder_disallows_downgrade: bool,
+    pub responder_silently_rejects: bool,
 }
diff --git a/src/challenge.rs b/src/challenge.rs
new file mode 100644
index 0000000..76e6cc5
--- /dev/null
+++ b/src/challenge.rs
@@ -0,0 +1,105 @@
+use std::hash::Hasher;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use rand_core::{CryptoRng, RngCore};
+
+use crate::antireplay::Window;
+use crate::crypto::{secure_eq, sha512::{HashSha512, SHA512_HASH_SIZE}};
+use crate::proto::*;
+
+pub struct ChallengeContext {
+    counter: AtomicU64,
+    antireplay_window: Window<COUNTER_WINDOW_MAX_OOO, {u64::MAX}>,
+    salt: [u8; SALT_SIZE],
+}
+
+/// Corresponds to Algorithm 11 found in Section 5.
+pub fn gen_null_response<Rng: RngCore + CryptoRng>(rng: &mut Rng) -> [u8; CHALLENGE_SIZE] {
+    let mut response = [0u8; CHALLENGE_SIZE];
+    response[POW_START..].copy_from_slice(&rng.next_u64().to_be_bytes());
+    response
+}
+/// Corresponds to Algorithm 13 found in Section 5.
+pub fn respond_to_challenge_in_place<Rng: RngCore + CryptoRng, Hash: HashSha512>(
+    rng: &mut Rng,
+    challenge: &[u8; CHALLENGE_SIZE],
+    pre_response: &mut [u8; CHALLENGE_SIZE],
+) {
+    if &challenge[POW_START..] == &pre_response[POW_START..] {
+        pre_response.copy_from_slice(challenge);
+        let mut pow = rng.next_u64();
+        let mut work_buf = [0u8; SHA512_HASH_SIZE];
+        loop {
+            pre_response[POW_START..].copy_from_slice(&pow.to_be_bytes());
+            if verify_pow::<Hash>(pre_response, &mut work_buf) {
+                return;
+            }
+            pow = pow.wrapping_add(1);
+        }
+    }
+}
+
+impl ChallengeContext {
+    pub fn new<Rng: RngCore + CryptoRng>(rng: &mut Rng) -> Self {
+        let mut salt = [0u8; SALT_SIZE];
+        rng.fill_bytes(&mut salt);
+        Self {
+            counter: AtomicU64::new(0),
+            antireplay_window: Window::new(),
+            salt,
+        }
+    }
+    /// Corresponds to Algorithm 12 found in Section 5.
+    pub fn process_hello<Hash: HashSha512>(
+        &self,
+        addr: &impl std::hash::Hash,
+        response: &[u8; CHALLENGE_SIZE],
+    ) -> Result<bool, [u8; CHALLENGE_SIZE]> {
+        let c = u64::from_be_bytes(response[..COUNTER_SIZE].try_into().unwrap());
+        let mut work_buf = [0u8; SHA512_HASH_SIZE];
+        if self.antireplay_window.check(c) && secure_eq(&response[COUNTER_SIZE..POW_START], &self.create_mac::<Hash>(c, addr)) && verify_pow::<Hash>(response, &mut work_buf) {
+            self.antireplay_window.update(c);
+            Ok(true)
+        } else {
+            let mut challenge = [0u8; CHALLENGE_SIZE];
+            let d = self.counter.fetch_add(1, Ordering::Relaxed);
+            challenge[..COUNTER_SIZE].copy_from_slice(&d.to_be_bytes());
+            challenge[COUNTER_SIZE..POW_START].copy_from_slice(&self.create_mac::<Hash>(d, addr));
+            challenge[POW_START..].copy_from_slice(&response[POW_START..]);
+            Err(challenge)
+        }
+    }
+    fn create_mac<Hash: HashSha512>(&self, c: u64, addr: &impl std::hash::Hash) -> [u8; MAC_SIZE] {
+        let mut h = Hash::new();
+        let mut hasher = ShaHasher(&mut h);
+        hasher.write(&c.to_be_bytes());
+        addr.hash(&mut hasher);
+        hasher.write(&self.salt);
+        drop(hasher);
+
+        let mut mac = [0u8; SHA512_HASH_SIZE];
+        h.finish_and_reset(&mut mac);
+        mac[..MAC_SIZE].try_into().unwrap()
+    }
+}
+
+/// Trick rust into letting us use a hasher that returns more than 64 bits.
+struct ShaHasher<'a, ShaImpl: HashSha512>(&'a mut ShaImpl);
+impl<'a, ShaImpl: HashSha512> Hasher for ShaHasher<'a, ShaImpl> {
+    fn finish(&self) -> u64 {
+        unimplemented!()
+    }
+    fn write(&mut self, bytes: &[u8]) {
+        self.0.update(bytes)
+    }
+}
+
+/// Check if the proof of work attached to the first message contains the correct number of leading
+/// zeros.
+fn verify_pow<Hash: HashSha512>(response: &[u8], work_buf: &mut [u8; SHA512_HASH_SIZE]) -> bool {
+    let mut hasher = Hash::new();
+    hasher.update(response);
+    hasher.finish_and_reset(work_buf);
+    let n = u32::from_be_bytes(work_buf[..4].try_into().unwrap());
+    n.leading_zeros() >= DIFFICULTY
+}
diff --git a/src/context.rs b/src/context.rs
new file mode 100644
index 0000000..ba69585
--- /dev/null
+++ b/src/context.rs
@@ -0,0 +1,438 @@
+use rand_core::RngCore;
+use std::cmp::Reverse;
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::num::NonZeroU32;
+use std::sync::{Arc, Mutex, Weak, RwLock};
+
+use crate::applicationlayer::ApplicationLayer;
+use crate::crypto::aes::{AES_256_KEY_SIZE, AES_GCM_IV_SIZE};
+use crate::indexed_heap::IndexedBinaryHeap;
+//use crate::fragmentation::{send_with_fragmentation, DefragBuffer};
+use crate::proto::*;
+use crate::result::{byzantine_fault, ReceiveError, ReceiveOk, SendError, SessionEvent};
+use crate::zeta::*;
+#[cfg(feature = "logging")]
+use crate::LogEvent::*;
+use crate::{challenge::ChallengeContext, result::OpenError};
+
+/// Macro to turn off logging at compile time.
+macro_rules! log {
+    ($app:expr, $event:expr) => {
+        #[cfg(feature = "logging")]
+        $app.event_log($event);
+    };
+}
+pub(crate) use log;
+
+/// Session context for local application.
+///
+/// Each application using ZSSP must create an instance of this to own sessions and
+/// defragment incoming packets that are not yet associated with a session.
+///
+/// Internally this is just a clonable Arc, so it can be safely shared with multiple threads.
+pub struct Context<App: ApplicationLayer>(Arc<ContextInner<App>>);
+impl<App: ApplicationLayer> Clone for Context<App> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+pub(crate) type SessionMap<App> = RwLock<HashMap<NonZeroU32, Weak<Session<App>>>>;
+
+pub(crate) struct ContextInner<App: ApplicationLayer> {
+    pub(crate) rng: Mutex<App::Rng>,
+    pub(crate) s_secret: App::KeyPair,
+    pub(crate) session_queue: Mutex<IndexedBinaryHeap<Weak<Session<App>>, Reverse<i64>>>,
+    pub(crate) session_map: SessionMap<App>,
+    //pub(crate) b2_map: Mutex<HashMap<NonZeroU32, StateB2<App>>>,
+
+    //hello_defrag: Mutex<DefragBuffer>,
+    challenge: ChallengeContext,
+}
+
+/// Corresponds to Figure 10 found in Section 4.3.
+fn to_aes_nonce(pn: &[u8; PACKET_NONCE_SIZE]) -> [u8; AES_GCM_IV_SIZE] {
+    let mut an = [0u8; AES_GCM_IV_SIZE];
+    an[2..].copy_from_slice(pn);
+    an
+}
+/// Corresponds to Figure 14 found near Section 6.
+fn to_packet_nonce(n: &[u8; AES_GCM_IV_SIZE]) -> &[u8; PACKET_NONCE_SIZE] {
+    (&n[n.len() - PACKET_NONCE_SIZE..]).try_into().unwrap()
+}
+
+impl<App: ApplicationLayer> Context<App> {
+    /// Create a new session context.
+    pub fn new(static_secret_key: App::KeyPair, mut rng: App::Rng) -> Self {
+        let challenge = ChallengeContext::new(&mut rng);
+        Self(Arc::new(ContextInner {
+            rng: Mutex::new(rng),
+            s_secret: static_secret_key,
+            session_map: Mutex::new(HashMap::new()),
+            b2_map: Mutex::new(HashMap::new()),
+            hello_defrag: Mutex::new(DefragBuffer::new(None)),
+            challenge: Mutex::new(challenge),
+            sessions: Mutex::new(HashMap::new()),
+        }))
+    }
+    /// Enable the ZeroTier Challenge Protocol, to protect this machine from CPU exhaustion DDOS
+    /// attacks.
+    pub fn enable_challenge(&self, enabled: bool) {
+        self.0.challenge.lock().unwrap().enabled = enabled;
+    }
+
+    /// Create a new session and send initial packet(s) to other side.
+    ///
+    /// This will return SendError::DataTooLarge if the combined size of the metadata and the local
+    /// static public blob (as retrieved from the application layer) exceed MAX_INIT_PAYLOAD_SIZE.
+    ///
+    /// * `app` - Application layer instance
+    /// * `send` - Function to be called to send one or more initial packets to the remote being
+    ///   contacted
+    /// * `mtu` - MTU for initial packets
+    /// * `static_remote_key` - Remote side's static public NIST P-384 key
+    /// * `session_data` - Arbitrary data meaningful to the application to include with session
+    ///   object
+    /// * `identity` - Payload to be sent to Bob that contains the information necessary
+    ///   for the upper protocol to authenticate and approve of Alice's identity
+    pub fn open(
+        &self,
+        app: App,
+        send: impl FnMut(Vec<u8>) -> bool,
+        mut mtu: usize,
+        static_remote_key: App::PublicKey,
+        session_data: App::SessionData,
+        identity: Vec<u8>,
+    ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
+        mtu = mtu.max(MIN_TRANSPORT_MTU);
+        let ctx = &self.0;
+
+        // Process zeta layer.
+        trans_to_a1(
+            app,
+            &ctx,
+            static_remote_key,
+            session_data,
+            identity,
+            |Packet(kid, nonce, payload): &Packet| {
+                // Process fragmentation layer.
+                send_with_fragmentation::<App>(send, mtu, *kid, to_packet_nonce(&nonce), payload, None);
+            },
+        )
+    }
+
+    /// Receive, authenticate, decrypt, and process a physical wire packet.
+    ///
+    /// * `app` - Interface to application using ZSSP
+    /// * `send_unassociated_reply` - Function to send reply packets directly when no session exists
+    /// * `send_unassociated_mtu` - MTU for unassociated replies
+    /// * `send_to` - Function to get senders for existing sessions, permitting MTU and path lookup
+    /// * `remote_address` - Whatever the remote address is, as long as you can Hash it
+    /// * `raw_fragment` - Buffer containing incoming wire packet
+    pub fn receive<'a, SendFn: FnMut(Vec<u8>) -> bool>(
+        &self,
+        app: App,
+        send_unassociated_reply: impl FnMut(Vec<u8>) -> bool,
+        mut send_unassociated_mtu: usize,
+        send_to: impl FnOnce(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
+        remote_address: &impl Hash,
+        raw_fragment: Vec<u8>,
+    ) -> Result<ReceiveOk<App>, ReceiveError<App::StorageError>> {
+        use crate::result::FaultType::*;
+        send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
+        let ctx = &self.0;
+
+        // Multiplex session.
+        let kid_recv = u32::from_be_bytes(raw_fragment[..KID_SIZE].try_into().unwrap());
+        if let Some(kid_recv) = NonZeroU32::new(kid_recv) {
+            let session = ctx.session_map.lock().unwrap().get(&kid_recv).map(|r| r.upgrade());
+            if let Some(Some(session)) = session {
+                // Process recv fragmentation layer.
+                let mut zeta = session.0.lock().unwrap();
+                let result = zeta.defrag.received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
+                    let (p, c) = from_nonce(n);
+                    if p != PACKET_TYPE_DATA {
+                        log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
+                    }
+                    if p == PACKET_TYPE_HANDSHAKE_RESPONSE {
+                        if !matches!(&zeta.beta, ZetaAutomata::A1(_)) {
+                            // A resent handshake response from Bob may have arrived out of order,
+                            // after we already received one.
+                            return Err(byzantine_fault!(OutOfSequence, false));
+                        }
+                        if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
+                            return Err(byzantine_fault!(ExpiredCounter, true));
+                        }
+                        Ok(())
+                    } else if PACKET_TYPE_USES_COUNTER_RANGE.contains(&p) {
+                        if !zeta.check_counter_window(c) {
+                            // The counter window has finite memory and so will occasionally give
+                            // false positives on very out-of-order packets.
+                            return Err(byzantine_fault!(ExpiredCounter, false));
+                        }
+                        Ok(())
+                    } else if p == PACKET_TYPE_HANDSHAKE_COMPLETION {
+                        // The handshake completion packet could have been resent.
+                        return Err(byzantine_fault!(InvalidPacket, false));
+                    } else {
+                        return Err(byzantine_fault!(InvalidPacket, true));
+                    }
+                })?;
+                if let Some((pn, mut assembled_packet)) = result {
+                    // Process recv zeta layer.
+                    let send_associated = |Packet(kid, nonce, payload): &Packet, hk: Option<&[u8; AES_256_KEY_SIZE]>| {
+                        if let Some((send_fragment, mut mtu)) = send_to(&session) {
+                            mtu = mtu.max(MIN_TRANSPORT_MTU);
+                            send_with_fragmentation::<App>(send_fragment, mtu, *kid, to_packet_nonce(&nonce), payload, hk);
+                        }
+                    };
+
+                    let (p, _) = from_nonce(&pn);
+                    let ret = match p {
+                        PACKET_TYPE_DATA => {
+                            received_payload_in_place(&mut zeta, kid_recv, to_aes_nonce(&pn), &mut assembled_packet)?;
+                            SessionEvent::Data(assembled_packet)
+                        }
+                        PACKET_TYPE_HANDSHAKE_RESPONSE => {
+                            log!(app, ReceivedRawX2);
+                            received_x2_trans(
+                                &mut zeta,
+                                &session,
+                                &app,
+                                &ctx,
+                                kid_recv,
+                                to_aes_nonce(&pn),
+                                assembled_packet,
+                                send_associated,
+                            )?;
+                            log!(app, X2IsAuthSentX3(&session));
+                            SessionEvent::Control
+                        }
+                        PACKET_TYPE_KEY_CONFIRM => {
+                            log!(app, ReceivedRawKeyConfirm);
+                            let result =
+                                received_c1_trans(&mut zeta, &app, &ctx.rng, kid_recv, to_aes_nonce(&pn), assembled_packet, send_associated)?;
+                            log!(app, KeyConfirmIsAuthSentAck(&session));
+                            if result {
+                                SessionEvent::Established
+                            } else {
+                                SessionEvent::Control
+                            }
+                        }
+                        PACKET_TYPE_ACK => {
+                            log!(app, ReceivedRawAck);
+                            received_c2_trans(&mut zeta, &app, &ctx.rng, kid_recv, to_aes_nonce(&pn), assembled_packet)?;
+                            log!(app, AckIsAuth(&session));
+                            SessionEvent::Control
+                        }
+                        PACKET_TYPE_REKEY_INIT => {
+                            log!(app, ReceivedRawK1);
+                            received_k1_trans(
+                                &mut zeta,
+                                &session,
+                                &app,
+                                &ctx.rng,
+                                &ctx.session_map,
+                                &ctx.s_secret,
+                                kid_recv,
+                                to_aes_nonce(&pn),
+                                assembled_packet,
+                                send_associated,
+                            )?;
+                            log!(app, K1IsAuthSentK2(&session));
+                            SessionEvent::Control
+                        }
+                        PACKET_TYPE_REKEY_COMPLETE => {
+                            log!(app, ReceivedRawK2);
+                            received_k2_trans(&mut zeta, &app, kid_recv, to_aes_nonce(&pn), assembled_packet, send_associated)?;
+                            log!(app, K2IsAuthSentKeyConfirm(&session));
+                            SessionEvent::Control
+                        }
+                        PACKET_TYPE_SESSION_REJECTED => {
+                            log!(app, ReceivedRawD);
+                            received_d_trans(&mut zeta, kid_recv, to_aes_nonce(&pn), assembled_packet)?;
+                            log!(app, DIsAuthClosedSession(&session));
+                            SessionEvent::Rejected
+                        }
+                        _ => return Err(byzantine_fault!(InvalidPacket, true)), // This is unreachable.
+                    };
+                    drop(zeta);
+                    Ok(ReceiveOk::Session(session, ret))
+                } else {
+                    Ok(ReceiveOk::Unassociated)
+                }
+            } else {
+                let mut b2_map = ctx.b2_map.lock().unwrap();
+                if let Entry::Occupied(mut entry) = b2_map.entry(kid_recv) {
+                    let zeta = entry.get_mut();
+                    // Process recv fragmentation layer.
+                    let result = zeta.defrag.received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
+                        let (p, c) = from_nonce(n);
+                        log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
+                        if p == PACKET_TYPE_HANDSHAKE_COMPLETION && c == 0 {
+                            Ok(())
+                        } else {
+                            Err(byzantine_fault!(InvalidPacket, true))
+                        }
+                    })?;
+                    if let Some((_, assembled_packet)) = result {
+                        log!(app, ReceivedRawX3);
+                        let zeta = entry.remove();
+                        let session = received_x3_trans(zeta, &app, ctx, kid_recv, assembled_packet, |Packet(kid, nonce, payload), hk| {
+                            send_with_fragmentation::<App>(
+                                send_unassociated_reply,
+                                send_unassociated_mtu,
+                                *kid,
+                                to_packet_nonce(&nonce),
+                                payload,
+                                hk,
+                            );
+                        })?;
+                        log!(app, X3IsAuthSentKeyConfirm(&session));
+                        Ok(ReceiveOk::Session(session, SessionEvent::NewSession))
+                    } else {
+                        Ok(ReceiveOk::Unassociated)
+                    }
+                } else {
+                    // When sessions are added or dropped or packets arrive extremely delayed it is
+                    // possible to receive no longer recognized key ids.
+                    Err(byzantine_fault!(UnknownLocalKeyId, false))
+                }
+            }
+        } else {
+            // Process recv fragmentation layer.
+            let result = ctx
+                .hello_defrag
+                .lock()
+                .unwrap()
+                .received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
+                    let (p, c) = from_nonce(n);
+                    log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
+                    if p == PACKET_TYPE_HANDSHAKE_HELLO || p == PACKET_TYPE_CHALLENGE {
+                        Ok(())
+                    } else {
+                        Err(byzantine_fault!(InvalidPacket, true))
+                    }
+                })?;
+            if let Some((n, mut assembled_packet)) = result {
+                let (p, _) = from_nonce(&n);
+                if p == PACKET_TYPE_HANDSHAKE_HELLO {
+                    log!(app, ReceivedRawX1);
+                    // Process recv challenge layer.
+                    let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
+                    let result = ctx
+                        .challenge
+                        .lock()
+                        .unwrap()
+                        .process_hello::<App::Hash>(remote_address, (&assembled_packet[challenge_start..]).try_into().unwrap());
+                    if let Err(challenge) = result {
+                        log!(app, X1FailedChallengeSentNewChallenge);
+                        let mut challenge_packet = Vec::new();
+                        challenge_packet.extend(&assembled_packet[..KID_SIZE]);
+                        challenge_packet.extend(&challenge);
+                        let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
+                        send_with_fragmentation::<App>(
+                            send_unassociated_reply,
+                            send_unassociated_mtu,
+                            0,
+                            to_packet_nonce(&nonce),
+                            &challenge_packet,
+                            None,
+                        );
+                        // If we issue a challenge the first hello packet will always fail.
+                        return Err(byzantine_fault!(FailedAuth, false));
+                    } else if let Ok(true) = result {
+                        log!(app, X1SucceededChallenge);
+                    }
+                    assembled_packet.truncate(challenge_start);
+
+                    // Process recv zeta layer.
+                    received_x1_trans(&app, &ctx, to_aes_nonce(&n), assembled_packet, |Packet(kid, nonce, payload), hk| {
+                        send_with_fragmentation::<App>(
+                            send_unassociated_reply,
+                            send_unassociated_mtu,
+                            *kid,
+                            to_packet_nonce(&nonce),
+                            payload,
+                            Some(hk),
+                        );
+                    })?;
+                    log!(app, X1IsAuthSentX2);
+                    Ok(ReceiveOk::Unassociated)
+                } else if p == PACKET_TYPE_CHALLENGE {
+                    log!(app, ReceivedRawChallenge);
+                    // Process recv challenge layer.
+                    if assembled_packet.len() != KID_SIZE + CHALLENGE_SIZE {
+                        return Err(byzantine_fault!(InvalidPacket, true));
+                    }
+                    if let Some(kid_recv) = NonZeroU32::new(u32::from_be_bytes(assembled_packet[..KID_SIZE].try_into().unwrap())) {
+                        if let Some(Some(session)) = ctx.session_map.lock().unwrap().get(&kid_recv).map(|r| r.upgrade()) {
+                            let mut zeta = session.0.lock().unwrap();
+                            respond_to_challenge(&mut zeta, &ctx.rng, &assembled_packet[KID_SIZE..].try_into().unwrap());
+                            log!(app, ChallengeIsAuth(&session));
+                            return Ok(ReceiveOk::Unassociated);
+                        }
+                    }
+                    Err(byzantine_fault!(UnknownLocalKeyId, true))
+                } else {
+                    Err(byzantine_fault!(InvalidPacket, true))
+                }
+            } else {
+                Ok(ReceiveOk::Unassociated)
+            }
+        }
+    }
+
+    /// Send data over the session.
+    ///
+    /// * `session` - The session to send to
+    /// * `send` - Function to call to send physical packet(s); the buffer passed to `send` is a
+    ///   slice of `data`
+    /// * `mtu` - The MTU of the link, all packets passed to `send` will be at most `mtu` in length
+    /// * `payload` - Data to send
+    pub fn send(&self, session: &Arc<Session<App>>, send: impl FnMut(Vec<u8>) -> bool, mut mtu: usize, payload: Vec<u8>) -> Result<(), SendError> {
+        mtu = mtu.max(MIN_TRANSPORT_MTU);
+        let mut zeta = session.0.lock().unwrap();
+        send_payload(&mut zeta, payload, |Packet(kid, nonce, payload), hk| {
+            send_with_fragmentation::<App>(send, mtu, *kid, to_packet_nonce(nonce), &payload, hk);
+        })
+    }
+
+    /// Perform periodic background service and cleanup tasks.
+    ///
+    /// This returns the number of milliseconds until it should be called again. The caller should
+    /// try to satisfy this but small variations in timing of up to a few seconds are not
+    /// a problem.
+    ///
+    /// * `send_to` - Function to get a sender and an MTU to send something over an active session
+    pub fn service<SendFn: FnMut(Vec<u8>) -> bool>(&self, app: App, mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>) -> i64 {
+        let ctx = &self.0;
+        let sessions = ctx.sessions.lock().unwrap();
+        let current_time = app.time();
+        let mut next_timer = i64::MAX;
+        for (_, session) in sessions.iter() {
+            if let Some(session) = session.upgrade() {
+                let mut zeta = session.0.lock().unwrap();
+                service(
+                    &mut zeta,
+                    &session,
+                    ctx,
+                    &app,
+                    current_time,
+                    |Packet(kid, nonce, payload): &Packet, hk| {
+                        if let Some((send_fragment, mut mtu)) = send_to(&session) {
+                            mtu = mtu.max(MIN_TRANSPORT_MTU);
+                            send_with_fragmentation::<App>(send_fragment, mtu, *kid, to_packet_nonce(&nonce), payload, hk);
+                        }
+                    },
+                );
+                next_timer = next_timer.min(zeta.next_timer());
+                zeta.defrag.service::<App>(current_time);
+            }
+        }
+        ctx.hello_defrag.lock().unwrap().service::<App>(current_time);
+        (App::SETTINGS.resend_time as i64).min(next_timer - current_time)
+    }
+}
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index 637d009..baec450 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -1,7 +1,9 @@
 // (c) 2020-2022 ZeroTier, Inc. -- currently proprietary pending actual release and licensing. See LICENSE.md.
 
-pub const AES_256_BLOCK_SIZE: usize = 16;
 pub const AES_256_KEY_SIZE: usize = 32;
+pub const AES_256_BLOCK_SIZE: usize = 16;
+pub const AES_GCM_TAG_SIZE: usize = 16;
+pub const AES_GCM_IV_SIZE: usize = 12;
 
 /// A trait for encrypting individual blocks of plaintext using AES-256.
 /// It is used for header authentication, for which we have a standard model proof that our
@@ -36,3 +38,33 @@ pub trait AesDec: Send + Sync {
     /// The plaintext should be written directly back out to `block`.
     fn decrypt_in_place(&self, block: &mut [u8; AES_256_BLOCK_SIZE]);
 }
+
+
+pub trait AesGcmEncContext {
+    fn encrypt(&mut self, input: &[u8], output: &mut [u8]);
+
+    fn finish(&mut self) -> [u8; AES_GCM_TAG_SIZE];
+}
+
+pub trait AesGcmDecContext {
+    fn decrypt(&mut self, input: &[u8], output: &mut [u8]);
+
+    #[must_use]
+    fn finish(&mut self, tag: &[u8; AES_GCM_TAG_SIZE]) -> bool;
+}
+
+pub trait HighThroughputAesGcmPool: Send + Sync {
+    type EncContext<'a>: AesGcmEncContext where Self: 'a;
+    type DecContext<'a>: AesGcmDecContext where Self: 'a;
+
+    fn new(encrypt_key: &[u8; AES_256_KEY_SIZE], decrypt_key: &[u8; AES_256_KEY_SIZE]) -> Self;
+
+    fn start_enc<'a>(&'a self, iv: &[u8; AES_GCM_IV_SIZE]) -> Self::EncContext<'a>;
+    fn start_dec<'a>(&'a self, iv: &[u8; AES_GCM_IV_SIZE]) -> Self::DecContext<'a>;
+}
+
+pub trait LowThroughputAesGcm {
+    fn encrypt_in_place(key: &[u8; AES_256_KEY_SIZE], iv: &[u8; AES_GCM_IV_SIZE], aad: &[u8], data: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE];
+    #[must_use]
+    fn decrypt_in_place(key: &[u8; AES_256_KEY_SIZE], iv: &[u8; AES_GCM_IV_SIZE], aad: &[u8], data: &mut [u8], tag: &[u8; AES_GCM_TAG_SIZE]) -> bool;
+}
diff --git a/src/crypto/aes_gcm.rs b/src/crypto/aes_gcm.rs
deleted file mode 100644
index c8328ed..0000000
--- a/src/crypto/aes_gcm.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// (c) 2020-2022 ZeroTier, Inc. -- currently proprietary pending actual release and licensing. See LICENSE.md.
-
-pub const AES_GCM_TAG_SIZE: usize = 16;
-pub const AES_GCM_IV_SIZE: usize = 12;
-pub const AES_GCM_KEY_SIZE: usize = super::aes::AES_256_KEY_SIZE;
-
-/// The order of calls to this trait is always
-/// `set_iv` -> `set_aad` -> `encrypt` -> `finish_encrypt`.
-/// `set_aad` and `encrypt` may not always be called. `encrypt_in_place` may be called instead of
-/// `encrypt`. `encrypt` may be called multiple times, it should start encryption of the input at the point in
-/// the keystream where encryption previously ended.
-/// An instance of this trait may be reused multiple times, each reuse should use the same key.
-/// If it is reused, `set_iv` will always be the very next call after `finish_encrypt`.
-///
-/// Implementations of this trait do not have to be Send + Sync,
-/// but if instances are wrapped in a `Mutex` they must satisfy the requirements of Send + Sync.
-///
-/// Instances must securely delete their keys when dropped.
-pub trait AesGcmEnc {
-    fn new(key: &[u8; AES_GCM_KEY_SIZE]) -> Self;
-
-    fn set_iv(&mut self, iv: &[u8; AES_GCM_IV_SIZE]);
-
-    fn set_aad(&mut self, aad: &[u8]);
-
-    fn encrypt(&mut self, input: &[u8], output: &mut [u8]);
-
-    fn encrypt_in_place(&mut self, data: &mut [u8]);
-
-    fn finish_encrypt(&mut self, output: &mut [u8; AES_GCM_TAG_SIZE]);
-}
-
-/// The order of calls to this trait is always
-/// `set_iv` -> `set_aad` -> `decrypt` -> `finish_decrypt`.
-/// `set_aad` and `decrypt` may not always be called. `decrypt_in_place` may be called instead of
-/// `decrypt`. `decrypt` may be called multiple times, it should start decryption of the input at the point in
-/// the keystream where decryption previously ended.
-/// An instance of this trait may be reused multiple times, each reuse should use the same key.
-/// If it is reused, `set_iv` will always be the very next call after `finish_decrypt`.
-///
-/// Implementations of this trait do not have to be Send + Sync,
-/// but if instances are wrapped in a `Mutex` they must satisfy the requirements of Send + Sync.
-///
-/// Instances must securely delete their keys when dropped.
-pub trait AesGcmDec {
-    fn new(key: &[u8; AES_GCM_KEY_SIZE]) -> Self;
-
-    fn set_iv(&mut self, iv: &[u8; AES_GCM_IV_SIZE]);
-
-    fn set_aad(&mut self, aad: &[u8]);
-
-    fn decrypt(&mut self, input: &[u8], output: &mut [u8]);
-
-    fn decrypt_in_place(&mut self, data: &mut [u8]);
-
-    fn finish_decrypt(&mut self, expected_tag: &[u8; AES_GCM_TAG_SIZE]) -> bool;
-}
diff --git a/src/crypto/kyber1024.rs b/src/crypto/kyber1024.rs
new file mode 100644
index 0000000..5cccc30
--- /dev/null
+++ b/src/crypto/kyber1024.rs
@@ -0,0 +1,36 @@
+use rand_core::{CryptoRng, RngCore};
+
+/// The size of a Kyber1024 public key, which is 1568 bytes.
+pub const KYBER_PUBLIC_KEY_SIZE: usize = 1568;
+/// The size of a Kyber1024 KEM ciphertext, which is 1568 bytes.
+pub const KYBER_CIPHERTEXT_SIZE: usize = 1568;
+/// The size of a Kyber1024 KEM plaintext, which is 32 bytes.
+pub const KYBER_PLAINTEXT_SIZE: usize = 32;
+
+/// Instances must securely delete the private key when dropped.
+pub trait Kyber1024PrivateKey<Rng: RngCore + CryptoRng>: Sized + Send + Sync {
+    /// Generate a Kyber1024 private key and public key pair, and return the raw bytes of the public
+    /// key.
+    /// The private key will be temporarily held in memory but the public key will be immediately
+    /// sent to the remote peer.
+    ///
+    /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
+    fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]);
+    /// Generate a Kyber1024 key encapsulation based on the given `public_key`, and return the
+    /// raw bytes of the generated ciphertext and plaintext. The ciphertext is immediately sent to
+    /// the remote peer and the plaintext is immediately hashed, both are quickly deleted.
+    ///
+    /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
+    ///
+    /// **CRITICAL**: This must return `None` if the given `public_key` is invalid in any way
+    /// according to the Kyber1024 spec.
+    #[must_use]
+    fn encapsulate(rng: &mut Rng, public_key: &[u8; KYBER_PUBLIC_KEY_SIZE], plaintext_out: &mut [u8; KYBER_PLAINTEXT_SIZE]) -> Option<[u8; KYBER_CIPHERTEXT_SIZE]>;
+    /// Decapsulate a Kyber1024 `ciphertext` received from the remote peer, retreiving
+    /// the raw bytes of the original plaintext. This plaintext is immediately hashed and deleted.
+    ///
+    /// **CRITICAL**: This must return `None` if the given `ciphertext` is invalid in any way
+    /// according to the Kyber1024 spec.
+    #[must_use]
+    fn decapsulate(&self, ciphertext: &[u8; KYBER_CIPHERTEXT_SIZE], plaintext_out: &mut [u8; KYBER_PLAINTEXT_SIZE]) -> bool;
+}
diff --git a/src/crypto/mod.rs b/src/crypto/mod.rs
index 0c7f601..22dcb9a 100644
--- a/src/crypto/mod.rs
+++ b/src/crypto/mod.rs
@@ -1,12 +1,25 @@
 // (c) 2020-2022 ZeroTier, Inc. -- currently proprietary pending actual release and licensing. See LICENSE.md.
 
 pub mod aes;
-pub mod aes_gcm;
 pub mod p384;
-pub mod secret;
 pub mod sha512;
+pub mod kyber1024;
 
 // We re-export our dependencies so it is less of a headache for the implementor to use the same
 // exact version of them.
 pub use pqc_kyber;
 pub use rand_core;
+
+/// Constant time byte slice equality.
+pub fn secure_eq<A: AsRef<[u8]> + ?Sized, B: AsRef<[u8]> + ?Sized>(a: &A, b: &B) -> bool {
+    let (a, b) = (a.as_ref(), b.as_ref());
+    if a.len() == b.len() {
+        let mut x = 0u8;
+        for (aa, bb) in a.iter().zip(b.iter()) {
+            x |= *aa ^ *bb;
+        }
+        x == 0
+    } else {
+        false
+    }
+}
diff --git a/src/crypto/p384.rs b/src/crypto/p384.rs
index d340356..647ac93 100644
--- a/src/crypto/p384.rs
+++ b/src/crypto/p384.rs
@@ -1,47 +1,46 @@
-// (c) 2020-2022 ZeroTier, Inc. -- currently proprietary pending actual release and licensing. See LICENSE.md.
-
-use super::rand_core::{CryptoRng, RngCore};
+use rand_core::{CryptoRng, RngCore};
 
+/// The size in bytes of a P-384 public key when in compressed SEC1-encoded format.
 pub const P384_PUBLIC_KEY_SIZE: usize = 49;
+/// The size in bytes of the raw output of ECDH between a P-384 public and private key.
 pub const P384_ECDH_SHARED_SECRET_SIZE: usize = 48;
 
 /// A NIST P-384 ECDH/ECDSA public key.
 pub trait P384PublicKey: Sized + Send + Sync {
-    /// Create a p384 public key from raw bytes.
+    /// Create a P-384 public key from raw bytes.
     ///
-    /// **CRITICAL**: This function must return `None` if the input `raw_key` is not on the P384 curve,
-    /// or if it breaks the P384 standard in any other way.
+    /// **CRITICAL**: This function must return `None` if the input `raw_key` is not on the P-384
+    /// curve, or if it breaks the P-384 spec in any other way.
     fn from_bytes(raw_key: &[u8; P384_PUBLIC_KEY_SIZE]) -> Option<Self>;
 
     /// Get the raw bytes that uniquely define the public key.
     ///
-    /// This must output the standard 49 byte NIST encoding of P384 public keys.
-    fn as_bytes(&self) -> &[u8; P384_PUBLIC_KEY_SIZE];
+    /// This must output the compressed SEC1 NIST encoding of P-384 public keys.
+    fn to_bytes(&self) -> [u8; P384_PUBLIC_KEY_SIZE];
 }
 
 /// A NIST P-384 ECDH/ECDSA public/private key pair.
 ///
 /// Instances must securely delete the private key when dropped.
-pub trait P384KeyPair: Send + Sync {
+pub trait P384KeyPair<Rng: RngCore + CryptoRng> {
+    /// The `PublicKeyP384` implementation which matches this `KeyPairP384` implementation.
     type PublicKey: P384PublicKey;
-    type Rng: RngCore + CryptoRng;
-    /// Randomly generate a new p384 keypair.
-    /// This function may use the provided RNG or it's own,
-    /// so long as the produced keys are cryptographically random.
-    fn generate(rng: &mut Self::Rng) -> Self;
+    /// Randomly generate a new P-384 keypair.
+    ///
+    /// This function may use the provided RNG or its own, so long as the output is cryptographically random.
+    fn generate(rng: &mut Rng) -> Self;
 
     /// Get the raw bytes that uniquely define the public key.
     ///
-    /// This must output the standard 49 byte NIST encoding of P384 public keys.
-    fn public_key_bytes(&self) -> &[u8; P384_PUBLIC_KEY_SIZE];
+    /// This must output the compressed SEC1 NIST encoding of P-384 public keys.
+    fn public_key_bytes(&self) -> [u8; P384_PUBLIC_KEY_SIZE];
 
     /// Perform ECDH key agreement, writing the raw (un-hashed!) ECDH secret to `output`.
     ///
-    /// **CRITICAL**: This function must return `false` if key agreement between this private key and
-    /// the input `other_public` key would result in an invalid, non-standard or predictable ECDH secret.
-    /// Please refer to the NIST spec for P384 ECDH key agreement, or better yet use a peer reviewed
+    /// **CRITICAL**: This function must return `None` if key agreement between this private key and
+    /// the input `public_key` key would result in an invalid, non-standard or predictable ECDH secret.
+    /// Please refer to the NIST spec for P-384 ECDH key agreement, or better yet use a peer reviewed
     /// library that has already implemented this correctly.
-    ///
-    /// If this function returns `false` then the contents of `output` will be discarded.
-    fn agree(&self, other_public: &Self::PublicKey, output: &mut [u8; P384_ECDH_SHARED_SECRET_SIZE]) -> bool;
+    #[must_use]
+    fn agree(&self, public_key: &Self::PublicKey, ecdh_out: &mut [u8; P384_ECDH_SHARED_SECRET_SIZE]) -> bool;
 }
diff --git a/src/crypto/secret.rs b/src/crypto/secret.rs
deleted file mode 100644
index 902eb6d..0000000
--- a/src/crypto/secret.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-// (c) 2020-2022 ZeroTier, Inc. -- currently proprietary pending actual release and licensing. See LICENSE.md.
-use std::{convert::TryInto, ptr::write_volatile};
-
-/// Constant time byte slice equality.
-pub fn secure_eq<A: AsRef<[u8]> + ?Sized, B: AsRef<[u8]> + ?Sized>(a: &A, b: &B) -> bool {
-    let (a, b) = (a.as_ref(), b.as_ref());
-    if a.len() == b.len() {
-        let mut x = 0u8;
-        for (aa, bb) in a.iter().zip(b.iter()) {
-            x |= *aa ^ *bb;
-        }
-        x == 0
-    } else {
-        false
-    }
-}
-
-/// Container for secrets that clears them on drop.
-///
-/// We can't be totally sure that things like libraries are doing this and it's
-/// hard to get every use of a secret anywhere, but using this in our code at
-/// least reduces the number of secrets that are left lying around in memory.
-///
-/// This is generally a low-risk thing since it's process memory that's protected,
-/// but it's still not a bad idea due to things like swap or obscure side channel
-/// attacks that allow memory to be read.
-#[derive(Clone)]
-#[repr(transparent)]
-pub struct Secret<const L: usize>(pub [u8; L]);
-
-impl<const L: usize> Secret<L> {
-    /// Create a new all-zero secret.
-    pub fn new() -> Self {
-        Self([0_u8; L])
-    }
-    /// Copy bytes into secret, then delete the previous value, will panic if the slice does not match the size of this secret.
-    pub fn from_bytes_then_delete(b: &mut [u8]) -> Self {
-        let ret = Self(b.try_into().unwrap());
-        b.fill(0);
-        ret
-    }
-    /// Moves bytes into secret, will panic if the slice does not match the size of this secret.
-    /// This is unsafe because it will not destroy the contents of its input.
-    /// # Safety
-    /// Make sure the contents of the input are securely deleted.
-    pub unsafe fn from_bytes(b: &[u8]) -> Self {
-        Self(b.try_into().unwrap())
-    }
-
-    pub fn as_ptr(&self) -> *const u8 {
-        self.0.as_ptr()
-    }
-
-    pub fn as_bytes(&self) -> &[u8; L] {
-        &self.0
-    }
-
-    /// Get the first N bytes of this secret as a fixed length array.
-    pub fn first_n<const N: usize>(&self) -> &[u8; N] {
-        assert!(N <= L);
-        unsafe { &*self.0.as_ptr().cast() }
-    }
-
-    /// Clone the first N bytes of this secret as another secret.
-    pub fn first_n_clone<const N: usize>(&self) -> Secret<N> {
-        Secret::<N>(*self.first_n())
-    }
-
-    pub fn overwrite(&mut self, src: &Self) {
-        self.0.copy_from_slice(&src.0);
-    }
-    pub fn overwrite_first_n<const N: usize>(&mut self, src: &Secret<N>) {
-        let amount = N.min(L);
-        self.0[..amount].copy_from_slice(&src.0[..amount]);
-    }
-
-    pub fn eq_bytes(&self, other: &[u8]) -> bool {
-        secure_eq(&self.0, other)
-    }
-}
-
-impl<const L: usize> Drop for Secret<L> {
-    fn drop(&mut self) {
-        unsafe {
-            for v in self.0.iter_mut() {
-                write_volatile(v, 0u8);
-            }
-        }
-    }
-}
-
-impl<const L: usize> Default for Secret<L> {
-    fn default() -> Self {
-        Self([0u8; L])
-    }
-}
-
-impl<const L: usize> AsRef<[u8]> for Secret<L> {
-    fn as_ref(&self) -> &[u8] {
-        &self.0
-    }
-}
-
-impl<const L: usize> AsRef<[u8; L]> for Secret<L> {
-    fn as_ref(&self) -> &[u8; L] {
-        &self.0
-    }
-}
-
-impl<const L: usize> AsMut<[u8]> for Secret<L> {
-    fn as_mut(&mut self) -> &mut [u8] {
-        &mut self.0
-    }
-}
-
-impl<const L: usize> AsMut<[u8; L]> for Secret<L> {
-    fn as_mut(&mut self) -> &mut [u8; L] {
-        &mut self.0
-    }
-}
-
-impl<const L: usize> PartialEq for Secret<L> {
-    fn eq(&self, other: &Self) -> bool {
-        secure_eq(&self.0, &other.0)
-    }
-}
-impl<const L: usize> Eq for Secret<L> {}
diff --git a/src/crypto/sha512.rs b/src/crypto/sha512.rs
index c2161be..bfb4b0d 100644
--- a/src/crypto/sha512.rs
+++ b/src/crypto/sha512.rs
@@ -2,41 +2,24 @@
 
 pub const SHA512_HASH_SIZE: usize = 64;
 
-/// Opaque SHA-512 implementation.
-/// Does not need to be threadsafe.
-pub trait Sha512 {
-    /// Allocate memory on the stack or heap for Sha512.
-    /// An instance of Sha512 will only ever be held on the stack.
+/// A SHA-512 implementation.
+pub trait HashSha512 {
+    /// Create a new instance of SHA-512 for streaming data to.
     fn new() -> Self;
-
-    /// Reinitialize the internal state of the hash function for a fresh input.
-    fn reset(&mut self);
-
-    fn update(&mut self, input: &[u8]);
-    /// Finish hashing the input and write the final hash to output.
-    ///
-    /// After this function is called, this instance of Sha512 will either be dropped
-    /// or `reset` will be called.
-    fn finish(&mut self, output: &mut [u8; SHA512_HASH_SIZE]);
+    /// Update the instance of SHA-512 with input `data`.
+    /// This must update the state of SHA-512 as if `data` was appended to the previous input.
+    fn update(&mut self, data: &[u8]);
+    /// Finish streaming input and output the final hash.
+    fn finish_and_reset(&mut self, output: &mut [u8; SHA512_HASH_SIZE]);
 }
 
+
 /// Opaque HMAC-SHA-512 implementation.
 /// Does not need to be threadsafe.
 pub trait HmacSha512 {
-    /// Allocate memory on the stack or heap for HmacSha512.
-    /// An instance of HmacSha512 will only ever be held on the stack.
-    ///
-    /// `reset` will always be called before `update` on a new instance of HmacSha512,
-    /// to make sure there is always a set key.
+    /// Allocate space on the stack or heap for repeated Hmac invocations.
     fn new() -> Self;
-    /// Reinitialize the internal state of the hash function for a fresh input.
-    /// The provided key should replace the previous Hmac key.
-    fn reset(&mut self, key: &[u8]);
-
-    fn update(&mut self, input: &[u8]);
-    /// Finish hashing the input and write the final hash to output.
-    ///
-    /// After this function is called, this instance of HmacSha512 will either be dropped
-    /// or `reset` will be called.
-    fn finish(&mut self, output: &mut [u8; SHA512_HASH_SIZE]);
+    /// Pure function for computing a single HMAC Hash. Repeat invocations of this function should
+    /// have no effect on each other.
+    fn hash(&mut self, key: &[u8], full_input: &[u8], output: &mut [u8; SHA512_HASH_SIZE]);
 }
diff --git a/src/lib.rs b/src/lib.rs
index 46d0713..16c9ec0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -8,19 +8,24 @@
 pub mod crypto;
 
 mod applicationlayer;
-mod frag_cache;
-mod fragged;
-mod handshake_cache;
+//mod frag_cache;
+//mod fragged;
+//mod handshake_cache;
 mod indexed_heap;
-mod log_event;
+//mod log_event;
 mod proto;
 mod ratchet_state;
 mod symmetric_state;
-mod zssp;
+mod antireplay;
+mod challenge;
+pub mod result;
+//mod zssp;
+mod zeta;
+mod context;
 
-pub mod error;
+//pub mod error;
 pub use crate::applicationlayer::ApplicationLayer;
-pub use crate::log_event::LogEvent;
-pub use crate::proto::{MAX_IDENTITY_BLOB_SIZE, MIN_PACKET_SIZE, MIN_TRANSPORT_MTU, RATCHET_SIZE};
+//pub use crate::log_event::LogEvent;
+//pub use crate::proto::{MAX_IDENTITY_BLOB_SIZE, MIN_PACKET_SIZE, MIN_TRANSPORT_MTU, RATCHET_SIZE};
 pub use crate::ratchet_state::RatchetState;
-pub use crate::zssp::{Context, ContextInner, IncomingSessionAction, ReceiveResult, Session, SessionEvent};
+//pub use crate::zssp::{Context, ContextInner, IncomingSessionAction, ReceiveResult, Session, SessionEvent};
diff --git a/src/log_event.rs b/src/log_event.rs
index bdc94b5..be543aa 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -7,7 +7,7 @@
  */
 use std::sync::Arc;
 
-use crate::{ApplicationLayer, Session};
+use crate::{ApplicationLayer, zssp::Session};
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
 pub enum LogEvent<'a, Application: ApplicationLayer> {
@@ -30,7 +30,7 @@ pub enum LogEvent<'a, Application: ApplicationLayer> {
     ReceiveUncheckedXK2,
     ReceiveValidXK2(&'a Arc<Session<Application>>),
     ReceiveUncheckedXK3,
-    ReceiveValidXK3(&'a Application::Data),
+    ReceiveValidXK3(&'a Application::SessionData),
     ReceiveUncheckedKK1,
     ReceiveValidKK1(&'a Arc<Session<Application>>),
     ReceiveUncheckedKK2,
diff --git a/src/proto.rs b/src/proto.rs
index 634e8d5..0d466a7 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -1,110 +1,55 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
 
-use std::hash::Hasher;
-use std::mem::size_of;
+/* Common constants */
 
-use crate::crypto::aes_gcm::AES_GCM_TAG_SIZE;
-use crate::crypto::p384::P384_PUBLIC_KEY_SIZE;
-use crate::crypto::pqc_kyber::{KYBER_CIPHERTEXTBYTES, KYBER_PUBLICKEYBYTES};
-use crate::crypto::sha512::{Sha512, SHA512_HASH_SIZE};
-use hex_literal::hex;
-
-/// Minimum size of a valid physical ZSSP packet of any type. Anything smaller is discarded.
-pub const MIN_PACKET_SIZE: usize = HEADER_SIZE + AES_GCM_TAG_SIZE;
+use crate::crypto::{sha512::SHA512_HASH_SIZE, p384::P384_PUBLIC_KEY_SIZE, kyber1024::{KYBER_PUBLIC_KEY_SIZE, KYBER_CIPHERTEXT_SIZE}, aes::AES_GCM_TAG_SIZE};
 
 /// Minimum physical MTU for ZSSP to function.
+/// If an MTU is passed to ZSSP that is lower than this, it will be ignored and instead this value
+/// will be used.
 pub const MIN_TRANSPORT_MTU: usize = 128;
 
-pub const RATCHET_SIZE: usize = 32;
+pub(crate) const KID_SIZE: usize = 4;
 
-/// The application has the ability to attach a data payload to Alice's handshake.
-/// It will be the first payload Bob receives from Alice.
-/// The application also must attach a static public identity to their handshake.
-/// The combined size of both in bytes must be at most this value.
-///
-/// If not ZSSP will return `OpenError::DataTooLarge` and refuse to create a session object.
-pub const MAX_IDENTITY_BLOB_SIZE: usize = NoiseXKPattern3::MAX_SIZE - NoiseXKPattern3::MIN_SIZE;
+/* Challenge protocol constants */
 
-/// Initial value of 'h'.
-/// echo -n 'Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512' | shasum -a 512
-pub(crate) const INITIAL_H: [u8; SHA512_HASH_SIZE] =
-    hex!("cd1f422196a5a614e24392cf34dcbf340ee61ad6ee6834274ff35fd42a7a5c44d04a045101555548a291778dd036b93ae21005a26c003213f57a5df9fb17f745");
-/// Initial value of 'ck' for rekeying.
-/// echo -n 'Noise_KKpsk0_P384_AESGCM_SHA512' | shasum -a 512
-pub(crate) const INITIAL_H_REKEY: [u8; SHA512_HASH_SIZE] =
-    hex!("daeedd651ac9c5173f2eaaff996beebac6f3f1bfe9a70bb1cc54fa1fb2bf46260d71a3c4fb4d4ee36f654c31773a8a15e5d5be974a0668dc7db70f4e13ed172e");
+pub(crate) const SALT_SIZE: usize = 32;
 
-pub(crate) const SESSION_ID_SIZE: usize = 4;
+pub(crate) const COUNTER_SIZE: usize = 8;
+pub(crate) const MAC_SIZE: usize = 16;
+pub(crate) const POW_SIZE: usize = 8;
+pub(crate) const POW_START: usize = COUNTER_SIZE + MAC_SIZE;
 
-pub(crate) const PACKET_TYPE_NOISE_XK_PATTERN_1: u8 = 0;
-pub(crate) const PACKET_TYPE_NOISE_XK_PATTERN_2: u8 = 1;
-pub(crate) const PACKET_TYPE_NOISE_XK_PATTERN_3: u8 = 2;
-pub(crate) const PACKET_TYPE_KEY_CONFIRM: u8 = 3;
-pub(crate) const PACKET_TYPE_ACK: u8 = 4;
-pub(crate) const PACKET_TYPE_NOISE_KK_PATTERN_1: u8 = 5;
-pub(crate) const PACKET_TYPE_NOISE_KK_PATTERN_2: u8 = 6;
-pub(crate) const PACKET_TYPE_SESSION_REJECTED: u8 = 7;
-pub(crate) const PACKET_TYPE_DATA: u8 = 8;
-pub(crate) const PACKET_TYPE_BOB_DOS_CHALLENGE: u8 = 9;
-pub(crate) const PACKET_TYPE_RANGE_TRANSPORT: std::ops::Range<u8> = 3..9;
-
-/// Noise asks that the counter be initialized to 0 but for out of order reasons we have
-/// to start it at 1.
-/// Since with unreliable transport the first counter could always end up dropped this is
-/// functionally equivalent to initializing to 0.
-pub(crate) const INIT_COUNTER: u64 = 0;
-pub(crate) const LABEL_RATCHET_STATE: u8 = b'R';
-pub(crate) const LABEL_HEADER_KEY: u8 = b'H';
-pub(crate) const LABEL_KEX_KEY: u8 = b'K';
-
-/// Size of keys used during derivation, mixing, etc.
-pub(crate) const NOISE_HASHLEN: usize = SHA512_HASH_SIZE;
+pub(crate) const CHALLENGE_SIZE: usize = COUNTER_SIZE + MAC_SIZE + POW_SIZE;
+pub(crate) const DIFFICULTY: u32 = 13;
 
+/* Fragmentation constants */
+/*
+Header:
+    [0..4]   recipient key id
+-- start AES(ck_es * h_e_e1_p) encrypted block --
+    [5]      fragment number (0..254)
+    [4]      fragment count (1..255)
+-- start packet nonce --
+    [6]      reserved zero
+    [7]      packet type
+    [8..16]  64-bit counter
+*/
 pub(crate) const HEADER_SIZE: usize = 16;
-pub(crate) const HEADER_PROTECT_ENC_START: usize = 4;
-pub(crate) const HEADER_PROTECT_ENC_END: usize = 20;
-pub(crate) const CHALLENGE_COUNTER_SIZE: usize = 8;
-pub(crate) const CHALLENGE_MAC_SIZE: usize = 16;
-pub(crate) const CHALLENGE_POW_SIZE: usize = 8;
-pub(crate) const CHALLENGE_SALT_SIZE: usize = 32;
+pub(crate) const PACKET_NONCE_SIZE: usize = 10;
 
-pub(crate) const MAX_NOISE_HANDSHAKE_SIZE: usize = MAX_FRAGMENTS * MIN_TRANSPORT_MTU;
-pub(crate) const CONTROL_PACKET_MAX_SIZE: usize = HEADER_SIZE + NoiseKKPattern1or2::SIZE + AES_GCM_TAG_SIZE;
-pub(crate) const CONTROL_PACKET_MIN_SIZE: usize = HEADER_SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const HEADER_AUTH_START: usize = 4;
+pub(crate) const HEADER_AUTH_END: usize = 20;
+pub(crate) const PACKET_NONCE_START: usize = HEADER_SIZE - PACKET_NONCE_SIZE;
 
-/// Determines the number of counters a session will remember. If a counter arrives over
-/// this amount out of order relative to other received counters, it is likely to be
-/// rejected on the basis that the session can't remember if this counter was replayed.
-/// Increasing this value makes a session consume more memory.
-pub(crate) const COUNTER_WINDOW_MAX_OOO: usize = 64;
-/// Maximum number of counter steps that the counter is allowed to skip ahead.
-/// This cannot be changed away from 2^24 without changing the header nonce handling code.
-pub(crate) const COUNTER_WINDOW_MAX_SKIP_AHEAD: u64 = 16777216;
-/// Similar to `COUNTER_WINDOW_MAX_OOO`, except this governs the receive context challenge
-/// counter rather than the session counter.
-/// When Bob issues a challenge to Alice to mitigate DDOS, Bob will only accept Alice's
-/// response once, and then its attached counter is added to the window.
-pub(crate) const CHALLENGE_COUNTER_WINDOW_MAX_OOO: usize = 32;
-/// We hard-expire the Noise counter long before we reach u64::MAX because of the ABA problem.
-/// Over (1<<16) threads would have to attempt to increment the counter at the same time
-/// to overflow it.
-/// Having (1<<16) threads active at the same time would crash basically any system.
-pub(crate) const THREAD_SAFE_COUNTER_HARD_EXPIRE: u64 = u64::MAX - (1 << 16);
+pub(crate) const FRAGMENT_NO_IDX: usize = 4;
+pub(crate) const FRAGMENT_COUNT_IDX: usize = 5;
+
+pub(crate) const MAX_FRAGMENTS: usize = 48;
 
-/// Maximum number of fragments a single packet may be split into. If a packet cannot fit
-/// into this number of fragments it will be dropped.
-pub(crate) const MAX_FRAGMENTS: usize = 48; // hard protocol max: 63
 /// Maximum window over which session packets may be reordered to be defragmented and
 /// reassembled. Out of order fragments may be dropped in favor of newer fragments.
 /// Increasing this value makes a session consume more significantly more memory.
 pub(crate) const SESSION_MAX_FRAGMENTS_OOO: usize = 32;
-
 /// The maximum number of unassociated packets that a receive context will cache.
 /// Additional packets will either be dropped or cause a different packet to be dropped
 /// from the cache.
@@ -124,8 +69,10 @@ pub(crate) const MAX_UNASSOCIATED_HANDSHAKE_STATES: usize = 32;
 
 /// The maximum size a packet that is not associated to a session may be.
 /// Excludes the size of headers for fragmentation.
-pub(crate) const MAX_UNASSOCIATED_PACKET_SIZE: usize = NoiseXKPattern1::MAX_SIZE - HEADER_SIZE;
+pub(crate) const MAX_UNASSOCIATED_PACKET_SIZE: usize = HANDSHAKE_HELLO_MAX_SIZE - HEADER_SIZE;
 
+
+/* Key exchange constants */
 /*
 XKhfs+psk2:
     <- s
@@ -142,155 +89,53 @@ KKpsk0:
     -> psk, e, es, ss
     <- e, ee, se
 */
-/*
-Header:
-    [0..4]   recipient key id
--- start AES(ck_es * h_e_e1_p) encrypted block --
-    [4]      fragment count (1..255)
-    [5]      fragment number (0..254)
-    [6]      reserved zero
--- start AES-GCM Nonce --
-    [7]      packet type
-    [8..16]  64-bit counter or packet id
-*/
-/// The first packet in Noise_XK exchange containing Alice's ephemeral keys, key id,
-/// and a random symmetric key to protect header fragmentation fields for this session.
-#[repr(C, packed)]
-pub(crate) struct NoiseXKPattern1 {
-    pub header: [u8; HEADER_SIZE],
-    /// -- start prologue --
-    pub alice_key_id: [u8; SESSION_ID_SIZE],
-    /// -- end prologue --
-    pub noise_e: [u8; P384_PUBLIC_KEY_SIZE],
-    /// -- start AES-GCM(k_es) encrypted section
-    pub noise_e1: [u8; KYBER_PUBLICKEYBYTES],
-    /// -- end encrypted section
-    pub e1_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-    pub payload: [u8; RATCHET_SIZE + RATCHET_SIZE + AES_GCM_TAG_SIZE + ChallengeResponse::SIZE],
-}
+pub(crate) const HASHLEN: usize = SHA512_HASH_SIZE;
+/// The size in bytes of both a ratchet key and a ratchet fingerprint.
+pub const RATCHET_SIZE: usize = 32;
 
-#[repr(C, packed)]
-pub(crate) struct ChallengeResponse {
-    pub challenge_counter: [u8; CHALLENGE_COUNTER_SIZE],
-    pub challenge_mac: [u8; CHALLENGE_MAC_SIZE],
-    pub challenge_pow: [u8; CHALLENGE_POW_SIZE],
-}
+pub(crate) const PROTOCOL_NAME_NOISE_XK: [u8; HASHLEN] = *b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+pub(crate) const PROTOCOL_NAME_NOISE_KK: [u8; HASHLEN] =
+    *b"Noise_KKpsk0_P384_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 
-impl NoiseXKPattern1 {
-    pub const PROLOGUE_START: usize = HEADER_SIZE;
-    pub const PROLOGUE_END: usize = Self::PROLOGUE_START + SESSION_ID_SIZE;
-    pub const E1_ENC_START: usize = Self::PROLOGUE_END + P384_PUBLIC_KEY_SIZE;
-    pub const E1_AUTH_START: usize = Self::E1_ENC_START + KYBER_PUBLICKEYBYTES;
-    pub const P_ENC_START: usize = Self::E1_AUTH_START + AES_GCM_TAG_SIZE;
+pub(crate) const LABEL_OTP_TO_RATCHET: &[u8; 19] = b"ZSSP_OTP_TO_RATCHET";
+pub(crate) const LABEL_KBKDF_CHAIN: &[u8; 4] = b"ZSSP";
+pub(crate) const LABEL_RATCHET_STATE: &[u8; 4] = b"ASKR";
+pub(crate) const LABEL_HEADER_KEY: &[u8; 4] = b"ASKH";
+pub(crate) const LABEL_KEX_KEY: &[u8; 4] = b"ASKK";
 
-    pub const MIN_SIZE: usize = Self::P_ENC_START + AES_GCM_TAG_SIZE + ChallengeResponse::SIZE;
-    pub const MAX_SIZE: usize = Self::MIN_SIZE + RATCHET_SIZE + RATCHET_SIZE;
-}
-impl ChallengeResponse {
-    pub const SIZE: usize = CHALLENGE_COUNTER_SIZE + CHALLENGE_MAC_SIZE + CHALLENGE_POW_SIZE;
-}
+pub(crate) const INIT_COUNTER: u64 = 0;
+pub(crate) const EXPIRE_AFTER_USES: u64 = 4294967295;
+pub(crate) const COUNTER_WINDOW_MAX_OOO: usize = 64;
+pub(crate) const COUNTER_WINDOW_MAX_SKIP_AHEAD: u64 = 1 << 24;
 
-#[repr(C, packed)]
-pub(crate) struct BobDOSChallenge {
-    pub header: [u8; HEADER_SIZE],
-    pub alice_key_id: [u8; SESSION_ID_SIZE],
-    pub challenge_counter: [u8; CHALLENGE_COUNTER_SIZE],
-    pub challenge_mac: [u8; CHALLENGE_MAC_SIZE],
-    pub prior_challenge_pow: [u8; CHALLENGE_POW_SIZE],
-}
+/* Packet constants */
 
-impl BobDOSChallenge {
-    pub const SIZE: usize = HEADER_SIZE + SESSION_ID_SIZE + CHALLENGE_COUNTER_SIZE + CHALLENGE_MAC_SIZE + CHALLENGE_POW_SIZE;
-}
+pub(crate) const PACKET_TYPE_HANDSHAKE_HELLO: u8 = 0;
+pub(crate) const PACKET_TYPE_HANDSHAKE_RESPONSE: u8 = 1;
+pub(crate) const PACKET_TYPE_HANDSHAKE_COMPLETION: u8 = 2;
+pub(crate) const PACKET_TYPE_KEY_CONFIRM: u8 = 3;
+pub(crate) const PACKET_TYPE_ACK: u8 = 4;
+pub(crate) const PACKET_TYPE_REKEY_INIT: u8 = 5;
+pub(crate) const PACKET_TYPE_REKEY_COMPLETE: u8 = 6;
+pub(crate) const PACKET_TYPE_SESSION_REJECTED: u8 = 7;
+pub(crate) const PACKET_TYPE_DATA: u8 = 8;
+pub(crate) const PACKET_TYPE_CHALLENGE: u8 = 9;
+pub(crate) const PACKET_TYPE_USES_COUNTER_RANGE: std::ops::Range<u8> = 3..9;
 
-/// The response to NoiseXKPattern1 containing Bob's ephemeral keys.
-#[repr(C, packed)]
-pub(crate) struct NoiseXKPattern2 {
-    pub header: [u8; HEADER_SIZE],
-    pub noise_e: [u8; P384_PUBLIC_KEY_SIZE],
-    /// -- start AES-GCM(k_es_ee) encrypted section
-    pub noise_ekem1: [u8; KYBER_CIPHERTEXTBYTES],
-    /// -- end encrypted section
-    pub ekem1_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-    /// -- start AES-GCM(k_es_ee_ekem1_psk) encrypted section
-    pub bob_key_id: [u8; SESSION_ID_SIZE],
-    /// -- end encrypted section
-    pub p_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-}
+pub(crate) const MAX_HANDSHAKE_SIZE: usize = MAX_FRAGMENTS * MIN_TRANSPORT_MTU;
 
-impl NoiseXKPattern2 {
-    pub const EKEM1_ENC_START: usize = HEADER_SIZE + P384_PUBLIC_KEY_SIZE;
-    pub const EKEM1_AUTH_START: usize = Self::EKEM1_ENC_START + KYBER_CIPHERTEXTBYTES;
-    pub const P_ENC_START: usize = Self::EKEM1_AUTH_START + AES_GCM_TAG_SIZE;
-    pub const P_AUTH_START: usize = Self::P_ENC_START + SESSION_ID_SIZE;
-    pub const P_AUTH_END: usize = Self::P_AUTH_START + AES_GCM_TAG_SIZE;
-    pub const SIZE: usize = Self::P_AUTH_END;
-}
+pub(crate) const HANDSHAKE_HELLO_MIN_SIZE: usize = KID_SIZE + P384_PUBLIC_KEY_SIZE + KYBER_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RATCHET_SIZE;
 
-/// Alice's final response containing her identity (she already knows Bob's) and meta-data.
-/// While Alice's response does match what is described in this struct,
-/// this struct is unused because it would contain variable length fields.
-/// It is present here for documentation purposes.
-#[repr(C, packed)]
-pub(crate) struct NoiseXKPattern3 {
-    pub header: [u8; HEADER_SIZE],
-    /// -- start AES-GCM(k_es_ee_ekem1_psk) encrypted section
-    pub noise_s: [u8; P384_PUBLIC_KEY_SIZE],
-    /// -- end encrypted section
-    pub s_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-    /// -- start AES-GCM(k_es_ee_ekem1_psk_se) encrypted section
-    pub alice_blob: [u8; 0],
-    /// -- end encrypted section
-    pub p_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-}
-impl NoiseXKPattern3 {
-    pub const MIN_SIZE: usize = HEADER_SIZE + P384_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
-    pub const MAX_SIZE: usize = MAX_NOISE_HANDSHAKE_SIZE;
-}
+pub(crate) const HANDSHAKE_RESPONSE_SIZE: usize = P384_PUBLIC_KEY_SIZE + KYBER_CIPHERTEXT_SIZE + AES_GCM_TAG_SIZE + KID_SIZE + AES_GCM_TAG_SIZE;
 
-#[repr(C, packed)]
-pub(crate) struct NoiseKKPattern1or2 {
-    pub header: [u8; HEADER_SIZE],
-    pub noise_e: [u8; P384_PUBLIC_KEY_SIZE],
-    pub key_id: [u8; SESSION_ID_SIZE],
-    pub gcm_tag: [u8; AES_GCM_TAG_SIZE],
-    pub kek_tag: [u8; AES_GCM_TAG_SIZE],
-}
-impl NoiseKKPattern1or2 {
-    pub const ENC_START: usize = HEADER_SIZE + P384_PUBLIC_KEY_SIZE;
-    pub const AUTH_START: usize = Self::ENC_START + SESSION_ID_SIZE;
-    pub const AUTH_END: usize = Self::AUTH_START + AES_GCM_TAG_SIZE;
-    pub const SIZE: usize = Self::AUTH_END + AES_GCM_TAG_SIZE;
-}
+pub(crate) const HANDSHAKE_COMPLETION_MIN_SIZE: usize = P384_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + 0 + AES_GCM_TAG_SIZE;
+pub(crate) const HANDSHAKE_COMPLETION_MAX_SIZE: usize = MAX_HANDSHAKE_SIZE;
 
-// Annotate only these structs as being compatible with byte_array_as_proto_buffer(). These structs
-// are packed flat buffers containing only byte or byte array fields, making them safe to treat
-// this way even on architectures that require type size aligned access.
-pub(crate) trait ProtocolFlatBuffer {}
-impl ProtocolFlatBuffer for NoiseXKPattern1 {}
-impl ProtocolFlatBuffer for NoiseXKPattern2 {}
-impl ProtocolFlatBuffer for NoiseKKPattern1or2 {}
-impl ProtocolFlatBuffer for BobDOSChallenge {}
-impl ProtocolFlatBuffer for ChallengeResponse {}
+pub(crate) const KEY_CONFIRMATION_SIZE: usize = AES_GCM_TAG_SIZE;
+pub(crate) const ACKNOWLEDGEMENT_SIZE: usize = AES_GCM_TAG_SIZE;
+pub(crate) const SESSION_REJECTED_SIZE: usize = AES_GCM_TAG_SIZE;
 
-#[inline(always)]
-pub(crate) fn byte_array_as_proto_buffer<B: ProtocolFlatBuffer>(b: &[u8]) -> &B {
-    assert!(b.len() >= size_of::<B>());
-    unsafe { &*b.as_ptr().cast() }
-}
+pub(crate) const REKEY_SIZE: usize = P384_PUBLIC_KEY_SIZE + KID_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
 
-#[inline(always)]
-pub(crate) fn byte_array_as_proto_buffer_mut<B: ProtocolFlatBuffer>(b: &mut [u8]) -> &mut B {
-    assert!(b.len() >= size_of::<B>());
-    unsafe { &mut *b.as_mut_ptr().cast() }
-}
-/// Trick rust into letting us use a hasher that returns more than 64 bits.
-pub(crate) struct ShaHasher<'a, ShaImpl: Sha512>(pub &'a mut ShaImpl);
-impl<'a, ShaImpl: Sha512> Hasher for ShaHasher<'a, ShaImpl> {
-    fn finish(&self) -> u64 {
-        panic!()
-    }
-    fn write(&mut self, bytes: &[u8]) {
-        self.0.update(bytes)
-    }
-}
+pub(crate) const MAX_IDENTITY_SIZE: usize = MAX_HANDSHAKE_SIZE - HANDSHAKE_COMPLETION_MIN_SIZE;
diff --git a/src/proto_old.rs b/src/proto_old.rs
new file mode 100644
index 0000000..2f83f3e
--- /dev/null
+++ b/src/proto_old.rs
@@ -0,0 +1,296 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * (c) ZeroTier, Inc.
+ * https://www.zerotier.com/
+ */
+
+use std::hash::Hasher;
+use std::mem::size_of;
+
+use crate::crypto::aes::AES_GCM_TAG_SIZE;
+use crate::crypto::p384::P384_PUBLIC_KEY_SIZE;
+use crate::crypto::pqc_kyber::{KYBER_CIPHERTEXTBYTES, KYBER_PUBLICKEYBYTES};
+use crate::crypto::sha512::{HashSha512, SHA512_HASH_SIZE};
+use hex_literal::hex;
+
+/// Minimum size of a valid physical ZSSP packet of any type. Anything smaller is discarded.
+pub const MIN_PACKET_SIZE: usize = HEADER_SIZE + AES_GCM_TAG_SIZE;
+
+/// Minimum physical MTU for ZSSP to function.
+pub const MIN_TRANSPORT_MTU: usize = 128;
+
+pub const RATCHET_SIZE: usize = 32;
+
+/// The application has the ability to attach a data payload to Alice's handshake.
+/// It will be the first payload Bob receives from Alice.
+/// The application also must attach a static public identity to their handshake.
+/// The combined size of both in bytes must be at most this value.
+///
+/// If not ZSSP will return `OpenError::DataTooLarge` and refuse to create a session object.
+pub const MAX_IDENTITY_BLOB_SIZE: usize = NoiseXKPattern3::MAX_SIZE - NoiseXKPattern3::MIN_SIZE;
+
+/// Initial value of 'h'.
+/// echo -n 'Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512' | shasum -a 512
+pub(crate) const INITIAL_H: [u8; SHA512_HASH_SIZE] =
+    hex!("cd1f422196a5a614e24392cf34dcbf340ee61ad6ee6834274ff35fd42a7a5c44d04a045101555548a291778dd036b93ae21005a26c003213f57a5df9fb17f745");
+/// Initial value of 'ck' for rekeying.
+/// echo -n 'Noise_KKpsk0_P384_AESGCM_SHA512' | shasum -a 512
+pub(crate) const INITIAL_H_REKEY: [u8; SHA512_HASH_SIZE] =
+    hex!("daeedd651ac9c5173f2eaaff996beebac6f3f1bfe9a70bb1cc54fa1fb2bf46260d71a3c4fb4d4ee36f654c31773a8a15e5d5be974a0668dc7db70f4e13ed172e");
+
+pub(crate) const SESSION_ID_SIZE: usize = 4;
+
+pub(crate) const PACKET_TYPE_NOISE_XK_PATTERN_1: u8 = 0;
+pub(crate) const PACKET_TYPE_NOISE_XK_PATTERN_2: u8 = 1;
+pub(crate) const PACKET_TYPE_NOISE_XK_PATTERN_3: u8 = 2;
+pub(crate) const PACKET_TYPE_KEY_CONFIRM: u8 = 3;
+pub(crate) const PACKET_TYPE_ACK: u8 = 4;
+pub(crate) const PACKET_TYPE_NOISE_KK_PATTERN_1: u8 = 5;
+pub(crate) const PACKET_TYPE_NOISE_KK_PATTERN_2: u8 = 6;
+pub(crate) const PACKET_TYPE_SESSION_REJECTED: u8 = 7;
+pub(crate) const PACKET_TYPE_DATA: u8 = 8;
+pub(crate) const PACKET_TYPE_BOB_DOS_CHALLENGE: u8 = 9;
+pub(crate) const PACKET_TYPE_RANGE_TRANSPORT: std::ops::Range<u8> = 3..9;
+
+/// Noise asks that the counter be initialized to 0 but for out of order reasons we have
+/// to start it at 1.
+/// Since with unreliable transport the first counter could always end up dropped this is
+/// functionally equivalent to initializing to 0.
+pub(crate) const INIT_COUNTER: u64 = 0;
+pub(crate) const LABEL_RATCHET_STATE: u8 = b'R';
+pub(crate) const LABEL_HEADER_KEY: u8 = b'H';
+pub(crate) const LABEL_KEX_KEY: u8 = b'K';
+
+/// Size of keys used during derivation, mixing, etc.
+pub(crate) const HASHLEN: usize = SHA512_HASH_SIZE;
+
+pub(crate) const HEADER_SIZE: usize = 16;
+pub(crate) const HEADER_PROTECT_ENC_START: usize = 4;
+pub(crate) const HEADER_PROTECT_ENC_END: usize = 20;
+pub(crate) const CHALLENGE_COUNTER_SIZE: usize = 8;
+pub(crate) const CHALLENGE_MAC_SIZE: usize = 16;
+pub(crate) const CHALLENGE_POW_SIZE: usize = 8;
+pub(crate) const CHALLENGE_SALT_SIZE: usize = 32;
+
+pub(crate) const MAX_NOISE_HANDSHAKE_SIZE: usize = MAX_FRAGMENTS * MIN_TRANSPORT_MTU;
+pub(crate) const CONTROL_PACKET_MAX_SIZE: usize = HEADER_SIZE + NoiseKKPattern1or2::SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const CONTROL_PACKET_MIN_SIZE: usize = HEADER_SIZE + AES_GCM_TAG_SIZE;
+
+/// Determines the number of counters a session will remember. If a counter arrives over
+/// this amount out of order relative to other received counters, it is likely to be
+/// rejected on the basis that the session can't remember if this counter was replayed.
+/// Increasing this value makes a session consume more memory.
+pub(crate) const COUNTER_WINDOW_MAX_OOO: usize = 64;
+/// Maximum number of counter steps that the counter is allowed to skip ahead.
+/// This cannot be changed away from 2^24 without changing the header nonce handling code.
+pub(crate) const COUNTER_WINDOW_MAX_SKIP_AHEAD: u64 = 16777216;
+/// Similar to `COUNTER_WINDOW_MAX_OOO`, except this governs the receive context challenge
+/// counter rather than the session counter.
+/// When Bob issues a challenge to Alice to mitigate DDOS, Bob will only accept Alice's
+/// response once, and then its attached counter is added to the window.
+pub(crate) const CHALLENGE_COUNTER_WINDOW_MAX_OOO: usize = 32;
+/// We hard-expire the Noise counter long before we reach u64::MAX because of the ABA problem.
+/// Over (1<<16) threads would have to attempt to increment the counter at the same time
+/// to overflow it.
+/// Having (1<<16) threads active at the same time would crash basically any system.
+pub(crate) const THREAD_SAFE_COUNTER_HARD_EXPIRE: u64 = u64::MAX - (1 << 16);
+
+/// Maximum number of fragments a single packet may be split into. If a packet cannot fit
+/// into this number of fragments it will be dropped.
+pub(crate) const MAX_FRAGMENTS: usize = 48; // hard protocol max: 63
+/// Maximum window over which session packets may be reordered to be defragmented and
+/// reassembled. Out of order fragments may be dropped in favor of newer fragments.
+/// Increasing this value makes a session consume more significantly more memory.
+pub(crate) const SESSION_MAX_FRAGMENTS_OOO: usize = 32;
+
+/// The maximum number of unassociated packets that a receive context will cache.
+/// Additional packets will either be dropped or cause a different packet to be dropped
+/// from the cache.
+/// Larger values consume more memory but provide better reliability and DDOS resistance.
+pub(crate) const MAX_UNASSOCIATED_PACKETS: usize = 32;
+/// The maximum number of fragments of unassociated packets that a receive context will
+/// cache.
+/// All unassociated fragments share the same buffer, when it fills up additional
+/// fragments will be dropped or cause other fragments to be dropped from the cache.
+/// Larger values consume more memory but provide better reliability and DDOS resistance.
+pub(crate) const MAX_UNASSOCIATED_FRAGMENTS: usize = 32 * 32;
+/// The maximum number of `NoiseXKBobHandshakeState` that a receive context will cache.
+/// These are extremely large and since Alice has not been authenticated we put a hard
+/// limit to how many we cache.
+/// Larger values consume more memory but provide better reliability and DDOS resistance.
+pub(crate) const MAX_UNASSOCIATED_HANDSHAKE_STATES: usize = 32;
+
+/// The maximum size a packet that is not associated to a session may be.
+/// Excludes the size of headers for fragmentation.
+pub(crate) const MAX_UNASSOCIATED_PACKET_SIZE: usize = NoiseXKPattern1::MAX_SIZE - HEADER_SIZE;
+
+/*
+XKhfs+psk2:
+    <- s
+    ...
+    -> e, es, e1
+    <- e, ee, ekem1, psk
+    -> s, se
+*/
+/*
+KKpsk0:
+    -> s
+    <- s
+    ...
+    -> psk, e, es, ss
+    <- e, ee, se
+*/
+/*
+Header:
+    [0..4]   recipient key id
+-- start AES(ck_es * h_e_e1_p) encrypted block --
+    [4]      fragment count (1..255)
+    [5]      fragment number (0..254)
+    [6]      reserved zero
+-- start AES-GCM Nonce --
+    [7]      packet type
+    [8..16]  64-bit counter or packet id
+*/
+/// The first packet in Noise_XK exchange containing Alice's ephemeral keys, key id,
+/// and a random symmetric key to protect header fragmentation fields for this session.
+#[repr(C, packed)]
+pub(crate) struct NoiseXKPattern1 {
+    pub header: [u8; HEADER_SIZE],
+    /// -- start prologue --
+    pub alice_key_id: [u8; SESSION_ID_SIZE],
+    /// -- end prologue --
+    pub noise_e: [u8; P384_PUBLIC_KEY_SIZE],
+    /// -- start AES-GCM(k_es) encrypted section
+    pub noise_e1: [u8; KYBER_PUBLICKEYBYTES],
+    /// -- end encrypted section
+    pub e1_gcm_tag: [u8; AES_GCM_TAG_SIZE],
+    pub payload: [u8; RATCHET_SIZE + RATCHET_SIZE + AES_GCM_TAG_SIZE + ChallengeResponse::SIZE],
+}
+
+#[repr(C, packed)]
+pub(crate) struct ChallengeResponse {
+    pub challenge_counter: [u8; CHALLENGE_COUNTER_SIZE],
+    pub challenge_mac: [u8; CHALLENGE_MAC_SIZE],
+    pub challenge_pow: [u8; CHALLENGE_POW_SIZE],
+}
+
+impl NoiseXKPattern1 {
+    pub const PROLOGUE_START: usize = HEADER_SIZE;
+    pub const PROLOGUE_END: usize = Self::PROLOGUE_START + SESSION_ID_SIZE;
+    pub const E1_ENC_START: usize = Self::PROLOGUE_END + P384_PUBLIC_KEY_SIZE;
+    pub const E1_AUTH_START: usize = Self::E1_ENC_START + KYBER_PUBLICKEYBYTES;
+    pub const P_ENC_START: usize = Self::E1_AUTH_START + AES_GCM_TAG_SIZE;
+
+    pub const MIN_SIZE: usize = Self::P_ENC_START + AES_GCM_TAG_SIZE + ChallengeResponse::SIZE;
+    pub const MAX_SIZE: usize = Self::MIN_SIZE + RATCHET_SIZE + RATCHET_SIZE;
+}
+impl ChallengeResponse {
+    pub const SIZE: usize = CHALLENGE_COUNTER_SIZE + CHALLENGE_MAC_SIZE + CHALLENGE_POW_SIZE;
+}
+
+#[repr(C, packed)]
+pub(crate) struct BobDOSChallenge {
+    pub header: [u8; HEADER_SIZE],
+    pub alice_key_id: [u8; SESSION_ID_SIZE],
+    pub challenge_counter: [u8; CHALLENGE_COUNTER_SIZE],
+    pub challenge_mac: [u8; CHALLENGE_MAC_SIZE],
+    pub prior_challenge_pow: [u8; CHALLENGE_POW_SIZE],
+}
+
+impl BobDOSChallenge {
+    pub const SIZE: usize = HEADER_SIZE + SESSION_ID_SIZE + CHALLENGE_COUNTER_SIZE + CHALLENGE_MAC_SIZE + CHALLENGE_POW_SIZE;
+}
+
+/// The response to NoiseXKPattern1 containing Bob's ephemeral keys.
+#[repr(C, packed)]
+pub(crate) struct NoiseXKPattern2 {
+    pub header: [u8; HEADER_SIZE],
+    pub noise_e: [u8; P384_PUBLIC_KEY_SIZE],
+    /// -- start AES-GCM(k_es_ee) encrypted section
+    pub noise_ekem1: [u8; KYBER_CIPHERTEXTBYTES],
+    /// -- end encrypted section
+    pub ekem1_gcm_tag: [u8; AES_GCM_TAG_SIZE],
+    /// -- start AES-GCM(k_es_ee_ekem1_psk) encrypted section
+    pub bob_key_id: [u8; SESSION_ID_SIZE],
+    /// -- end encrypted section
+    pub p_gcm_tag: [u8; AES_GCM_TAG_SIZE],
+}
+
+impl NoiseXKPattern2 {
+    pub const EKEM1_ENC_START: usize = HEADER_SIZE + P384_PUBLIC_KEY_SIZE;
+    pub const EKEM1_AUTH_START: usize = Self::EKEM1_ENC_START + KYBER_CIPHERTEXTBYTES;
+    pub const P_ENC_START: usize = Self::EKEM1_AUTH_START + AES_GCM_TAG_SIZE;
+    pub const P_AUTH_START: usize = Self::P_ENC_START + SESSION_ID_SIZE;
+    pub const P_AUTH_END: usize = Self::P_AUTH_START + AES_GCM_TAG_SIZE;
+    pub const SIZE: usize = Self::P_AUTH_END;
+}
+
+/// Alice's final response containing her identity (she already knows Bob's) and meta-data.
+/// While Alice's response does match what is described in this struct,
+/// this struct is unused because it would contain variable length fields.
+/// It is present here for documentation purposes.
+#[repr(C, packed)]
+pub(crate) struct NoiseXKPattern3 {
+    pub header: [u8; HEADER_SIZE],
+    /// -- start AES-GCM(k_es_ee_ekem1_psk) encrypted section
+    pub noise_s: [u8; P384_PUBLIC_KEY_SIZE],
+    /// -- end encrypted section
+    pub s_gcm_tag: [u8; AES_GCM_TAG_SIZE],
+    /// -- start AES-GCM(k_es_ee_ekem1_psk_se) encrypted section
+    pub alice_blob: [u8; 0],
+    /// -- end encrypted section
+    pub p_gcm_tag: [u8; AES_GCM_TAG_SIZE],
+}
+impl NoiseXKPattern3 {
+    pub const MIN_SIZE: usize = HEADER_SIZE + P384_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
+    pub const MAX_SIZE: usize = MAX_NOISE_HANDSHAKE_SIZE;
+}
+
+#[repr(C, packed)]
+pub(crate) struct NoiseKKPattern1or2 {
+    pub header: [u8; HEADER_SIZE],
+    pub noise_e: [u8; P384_PUBLIC_KEY_SIZE],
+    pub key_id: [u8; SESSION_ID_SIZE],
+    pub gcm_tag: [u8; AES_GCM_TAG_SIZE],
+    pub kek_tag: [u8; AES_GCM_TAG_SIZE],
+}
+impl NoiseKKPattern1or2 {
+    pub const ENC_START: usize = HEADER_SIZE + P384_PUBLIC_KEY_SIZE;
+    pub const AUTH_START: usize = Self::ENC_START + SESSION_ID_SIZE;
+    pub const AUTH_END: usize = Self::AUTH_START + AES_GCM_TAG_SIZE;
+    pub const SIZE: usize = Self::AUTH_END + AES_GCM_TAG_SIZE;
+}
+
+// Annotate only these structs as being compatible with byte_array_as_proto_buffer(). These structs
+// are packed flat buffers containing only byte or byte array fields, making them safe to treat
+// this way even on architectures that require type size aligned access.
+pub(crate) trait ProtocolFlatBuffer {}
+impl ProtocolFlatBuffer for NoiseXKPattern1 {}
+impl ProtocolFlatBuffer for NoiseXKPattern2 {}
+impl ProtocolFlatBuffer for NoiseKKPattern1or2 {}
+impl ProtocolFlatBuffer for BobDOSChallenge {}
+impl ProtocolFlatBuffer for ChallengeResponse {}
+
+#[inline(always)]
+pub(crate) fn byte_array_as_proto_buffer<B: ProtocolFlatBuffer>(b: &[u8]) -> &B {
+    assert!(b.len() >= size_of::<B>());
+    unsafe { &*b.as_ptr().cast() }
+}
+
+#[inline(always)]
+pub(crate) fn byte_array_as_proto_buffer_mut<B: ProtocolFlatBuffer>(b: &mut [u8]) -> &mut B {
+    assert!(b.len() >= size_of::<B>());
+    unsafe { &mut *b.as_mut_ptr().cast() }
+}
+/// Trick rust into letting us use a hasher that returns more than 64 bits.
+pub(crate) struct ShaHasher<'a, ShaImpl: HashSha512>(pub &'a mut ShaImpl);
+impl<'a, ShaImpl: HashSha512> Hasher for ShaHasher<'a, ShaImpl> {
+    fn finish(&self) -> u64 {
+        panic!()
+    }
+    fn write(&mut self, bytes: &[u8]) {
+        self.0.update(bytes)
+    }
+}
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index 273a358..378eb78 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -1,62 +1,76 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
+use zeroize::Zeroizing;
 
-use std::num::NonZeroU64;
-
-use crate::crypto::secret::Secret;
-use crate::RATCHET_SIZE;
-
-#[derive(Clone, PartialEq, Eq)]
-pub enum RatchetState {
-    Null,
-    Empty,
-    NonEmpty(NonEmptyRatchetState),
-}
-use RatchetState::*;
-impl RatchetState {
-    pub fn new_nonempty(key: Secret<RATCHET_SIZE>, fingerprint: Secret<RATCHET_SIZE>, chain_len: NonZeroU64) -> Self {
-        NonEmpty(NonEmptyRatchetState { key, fingerprint, chain_len })
-    }
-    pub fn new_initial_states() -> [RatchetState; 2] {
-        [RatchetState::Empty, RatchetState::Null]
-    }
-    pub fn is_null(&self) -> bool {
-        matches!(self, Null)
-    }
-    pub fn is_empty(&self) -> bool {
-        matches!(self, Empty)
-    }
-    pub fn nonempty(&self) -> Option<&NonEmptyRatchetState> {
-        match self {
-            NonEmpty(rs) => Some(rs),
-            _ => None,
-        }
-    }
-    pub fn chain_len(&self) -> u64 {
-        self.nonempty().map_or(0, |rs| rs.chain_len.get())
-    }
-    pub fn fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
-        self.nonempty().map(|rs| rs.fingerprint.as_ref())
-    }
-    pub fn key(&self) -> Option<&[u8; RATCHET_SIZE]> {
-        const ZERO_KEY: [u8; RATCHET_SIZE] = [0u8; RATCHET_SIZE];
-        match self {
-            Null => None,
-            Empty => Some(&ZERO_KEY),
-            NonEmpty(rs) => Some(rs.key.as_ref()),
-        }
-    }
-}
+use crate::crypto::secure_eq;
+use crate::proto::*;
 /// A ratchet key and fingerprint,
 /// along with the length of the ratchet chain the keys were derived from.
-#[derive(Clone, PartialEq, Eq)]
-pub struct NonEmptyRatchetState {
-    pub key: Secret<RATCHET_SIZE>,
-    pub fingerprint: Secret<RATCHET_SIZE>,
-    pub chain_len: NonZeroU64,
+///
+/// Corresponds to the Ratchet Key and Ratchet Fingerprint described in Section 3.
+#[derive(Clone, Eq)]
+pub struct RatchetState {
+    pub key: Zeroizing<[u8; RATCHET_SIZE]>,
+    pub fingerprint: Option<Zeroizing<[u8; RATCHET_SIZE]>>,
+    pub chain_len: u64,
+}
+impl PartialEq for RatchetState {
+    fn eq(&self, other: &Self) -> bool {
+        secure_eq(&self.key, &other.key)
+            & (self.chain_len == other.chain_len)
+            & match (self.fingerprint.as_ref(), other.fingerprint.as_ref()) {
+                (Some(rf1), Some(rf2)) => secure_eq(rf1, rf2),
+                (None, None) => true,
+                _ => false,
+            }
+    }
+}
+impl RatchetState {
+    pub fn new(key: Zeroizing<[u8; RATCHET_SIZE]>, fingerprint: Zeroizing<[u8; RATCHET_SIZE]>, chain_len: u64) -> Self {
+        RatchetState { key, fingerprint: Some(fingerprint), chain_len }
+    }
+    pub fn new_raw(key: [u8; RATCHET_SIZE], fingerprint: [u8; RATCHET_SIZE], chain_len: u64) -> Self {
+        RatchetState {
+            key: Zeroizing::new(key),
+            fingerprint: Some(Zeroizing::new(fingerprint)),
+            chain_len,
+        }
+    }
+    pub fn empty() -> Self {
+        RatchetState {
+            key: Zeroizing::new([0u8; RATCHET_SIZE]),
+            fingerprint: None,
+            chain_len: 0,
+        }
+    }
+    //pub fn new_from_otp<Hmac: HmacSha512>(otp: &[u8]) -> RatchetState {
+    //    let mut buffer = Vec::new();
+    //    buffer.push(1);
+    //    buffer.extend(LABEL_OTP_TO_RATCHET);
+    //    buffer.push(0x00);
+    //    buffer.extend((2u16 * 512u16).to_be_bytes());
+    //    let r1 = Hmac::hmac(otp, &buffer);
+    //    buffer[0] = 2;
+    //    let r2 = Hmac::hmac(otp, &buffer);
+    //    Self::new(
+    //        Zeroizing::new(r1[..RATCHET_SIZE].try_into().unwrap()),
+    //        Zeroizing::new(r2[..RATCHET_SIZE].try_into().unwrap()),
+    //        1,
+    //    )
+    //}
+
+    pub fn new_initial_states() -> (RatchetState, Option<RatchetState>) {
+        (RatchetState::empty(), None)
+    }
+    //pub fn new_otp_states<Hmac: HashSha512>(otp: &[u8]) -> (RatchetState, Option<RatchetState>) {
+    //    (RatchetState::new_from_otp::<Hmac>(otp), None)
+    //}
+
+    pub fn is_empty(&self) -> bool {
+        self.fingerprint.is_none()
+    }
+    pub fn fingerprint_eq(&self, rf: &[u8; RATCHET_SIZE]) -> bool {
+        self.fingerprint.as_ref().map_or(false, |rf0| secure_eq(rf0, rf))
+    }
+    pub fn fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
+        self.fingerprint.as_deref()
+    }
 }
diff --git a/src/ratchet_state_old.rs b/src/ratchet_state_old.rs
new file mode 100644
index 0000000..73519e6
--- /dev/null
+++ b/src/ratchet_state_old.rs
@@ -0,0 +1,62 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * (c) ZeroTier, Inc.
+ * https://www.zerotier.com/
+ */
+
+use std::num::NonZeroU64;
+
+#[derive(Clone, PartialEq, Eq)]
+pub enum RatchetState {
+    Null,
+    Empty,
+    NonEmpty(NonEmptyRatchetState),
+}
+use RatchetState::*;
+use zeroize::Zeroizing;
+
+use crate::proto::RATCHET_SIZE;
+impl RatchetState {
+    pub fn new_nonempty(key: Zeroizing<[u8; RATCHET_SIZE]>, fingerprint: Zeroizing<[u8; RATCHET_SIZE]>, chain_len: NonZeroU64) -> Self {
+        NonEmpty(NonEmptyRatchetState { key, fingerprint, chain_len })
+    }
+    pub fn new_initial_states() -> [RatchetState; 2] {
+        [RatchetState::Empty, RatchetState::Null]
+    }
+    pub fn is_null(&self) -> bool {
+        matches!(self, Null)
+    }
+    pub fn is_empty(&self) -> bool {
+        matches!(self, Empty)
+    }
+    pub fn nonempty(&self) -> Option<&NonEmptyRatchetState> {
+        match self {
+            NonEmpty(rs) => Some(rs),
+            _ => None,
+        }
+    }
+    pub fn chain_len(&self) -> u64 {
+        self.nonempty().map_or(0, |rs| rs.chain_len.get())
+    }
+    //pub fn fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
+    //    self.nonempty().map(|rs| rs.fingerprint.as_ref())
+    //}
+    //pub fn key(&self) -> Option<&[u8; RATCHET_SIZE]> {
+    //    const ZERO_KEY: [u8; RATCHET_SIZE] = [0u8; RATCHET_SIZE];
+    //    match self {
+    //        Null => None,
+    //        Empty => Some(&ZERO_KEY),
+    //        NonEmpty(rs) => Some(rs.key.as_ref()),
+    //    }
+    //}
+}
+/// A ratchet key and fingerprint,
+/// along with the length of the ratchet chain the keys were derived from.
+#[derive(Clone, PartialEq, Eq)]
+pub struct NonEmptyRatchetState {
+    pub key: Zeroizing<[u8; RATCHET_SIZE]>,
+    pub fingerprint: Zeroizing<[u8; RATCHET_SIZE]>,
+    pub chain_len: NonZeroU64,
+}
diff --git a/src/result.rs b/src/result.rs
new file mode 100644
index 0000000..d542227
--- /dev/null
+++ b/src/result.rs
@@ -0,0 +1,162 @@
+use std::sync::Arc;
+
+use crate::applicationlayer::ApplicationLayer;
+use crate::zeta::Session;
+
+/// An error that can occur when attempting to open a session.
+/// Depending on the error type trying again may not work.
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum OpenError<IoError> {
+    /// An invalid parameter was supplied to the function.
+    InvalidPublicKey,
+
+    RatchetIoError(IoError),
+}
+
+/// An error that can occur when attempting to send data over a session.
+/// Depending on the error type trying again may not work.
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum SendError {
+    /// An invalid parameter was supplied to the function.
+    InvalidParameter,
+
+    /// The session has been marked as expired and refuses to send data.
+    /// Several components of ZSSP can cause this to occur, but the most likely situation to be seen
+    /// in practice is where rekeying repeatedly fails due to exceedingly bad network conditions.
+    ///
+    /// The associated session will no longer send or receive data and must be immediately dropped.
+    SessionExpired,
+
+    /// Attempt to send using a session without a shared symmetric key.
+    /// The caller should wait until the handshake has completed.
+    SessionNotEstablished,
+
+    /// Data object is too large to send, even with fragmentation.
+    DataTooLarge,
+}
+
+/// A type of fault occurred because we received a bad packet.
+///
+/// An unauthenticated attacker can intentionally trigger any of these, so it is best to
+/// treat these as raw user input that needs to be sanitize.
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum FaultType {
+    /// The received packet was addressed to an unrecognized local session.
+    UnknownLocalKeyId,
+
+    /// The received packet from the remote peer was not well formed.
+    InvalidPacket,
+
+    /// Packet failed one or more authentication (MAC) checks.
+    FailedAuth,
+
+    /// Packet counter was repeated or outside window of allowed counter values.
+    ExpiredCounter,
+
+    /// Packet contained protocol control parameters that are disallowed at this point in
+    /// time by ZSSP.
+    OutOfSequence,
+}
+
+/// An error that occurred during the receipt of a given packet.
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum ReceiveError<IoError> {
+    /// A type of fault that can occur because a remote peer sent us a bad packet.
+    /// Such packets will be ignored by ZSSP but a user of ZSSP might want to log
+    /// them for debugging or tracing.
+    ///
+    /// Because an unauthenticated remote peer can force these to occur with specific
+    /// contained information, it is recommended in production to either drop these
+    /// immediately, or log them safely to a local output stream and then drop them.
+    ByzantineFault {
+        /// The type of fault that has occurred. Be cautious if you choose to read this
+        /// value, as an attacker has control over it.
+        error: FaultType,
+        /// Some byzantine faults within ZSSP are naturally occurring, i.e. they can occur
+        /// between two well behaved and trusted parties executing the protocol.
+        /// This boolean is false if this is one of these faults. If you go to the file and
+        /// line number specified by this error you will find a comment describing
+        /// how and why exactly this fault can occur naturally.
+        ///
+        /// Faults that can occur because the underlying communication medium is lossy and
+        /// sequentially inconsistent (as in UDP) are considered naturally occurring.
+        /// However ZSSP considers faults that occur because data integrity has not been
+        /// persevered (i.e. bits have been flipped) to be unnatural.
+        /// ZSSP also considers collisions of what are supposed to be uniform random
+        /// numbers to be unnatural.
+        unnatural: bool,
+        /// The file of this implementation of ZSSP from which this error was generated.
+        #[cfg(feature = "debug")]
+        file: &'static str,
+        /// The line number of this implementation of ZSSP from which this error was
+        /// generated. As such this number uniquely identifies each possible fault that
+        /// can occur during ZSSP. Advanced user can use this information to debug more
+        /// complicated usages of ZSSP.
+        #[cfg(feature = "debug")]
+        line: u32,
+    },
+
+    /// Rekeying failed and session secret has reached its hard usage count limit.
+    /// The associated session will no longer function and has to be dropped.
+    MaxKeyLifetimeExceeded,
+
+    /// One of the ratchet saving or lookup functions returned an error, so the packet had to be
+    /// dropped.
+    RatchetIoError(IoError),
+}
+
+macro_rules! byzantine_fault {
+    ($name:expr, $unnatural:ident) => {
+        ReceiveError::ByzantineFault {
+            #[cfg(feature = "debug")]
+            file: file!(),
+            #[cfg(feature = "debug")]
+            line: line!(),
+            error: $name,
+            unnatural: $unnatural,
+        }
+    };
+}
+pub(crate) use byzantine_fault;
+
+/// Result generated by the context packet receive function, with possible payloads.
+#[derive(Clone)]
+pub enum ReceiveOk<App: ApplicationLayer> {
+    /// Packet superficially appeared valid but is not associated with a session yet.
+    /// This can occur because the packet was only a fragment of a larger packet,
+    /// or if it was a control packet that does not go through full Noise authentication.
+    Unassociated,
+    /// Packet was authentic and belongs to this specific session.
+    Session(Arc<Session<App>>, SessionEvent),
+}
+/// Something that can occur to an associated session when a packet is received successfully,
+/// including receiving a payload of decrypted, authenticated data.
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum SessionEvent {
+    /// The received packet was valid, and it contained the necessary keys to fully establish a new
+    /// session with Alice, the handshake initiator.
+    ///
+    /// If the session Arc returned is dropped, the session with this peer will be immediately
+    /// terminated. Save the session Arc to some long lived datastructure to keep it alive.
+    NewSession,
+    /// When Alice calls `Context::open`, a session will be created, but Bob will not yet have
+    /// received this session. They will have to successfully complete a handshake first.
+    ///
+    /// Alice will receive this return value when the received packet confirms both parties
+    /// have completed the initial handshake and now have a shared session with each other.
+    /// If according to the upper protocol, Bob is the first party to send data, it is possible for
+    /// Alice to start receiving data from Bob before this value is returned.
+    ///
+    /// This return value can only occur once per session, only for session objects that were
+    /// created with `Context::open`.
+    Established,
+    /// Bob explicitly refused to establish a session with Alice, and sent us an error code.
+    /// The application should immediately drop this session as Bob will not allow us to connect.
+    ///
+    /// This return value cannot occur after a session is fully established.
+    Rejected,
+    /// The received packet was valid and a data payload was decoded and authenticated.
+    Data(Vec<u8>),
+    /// The received packet was some authentic protocol control packet. No action needs to be taken.
+    Control,
+}
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index e6e5e52..a2caf2b 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -1,116 +1,34 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-use crate::crypto::aes::AES_256_KEY_SIZE;
-use crate::crypto::secret::Secret;
-use crate::crypto::sha512::HmacSha512;
+use std::marker::PhantomData;
 
-use crate::proto::NOISE_HASHLEN;
+use arrayvec::ArrayVec;
+use zeroize::Zeroizing;
 
-#[derive(Clone)]
-pub(crate) struct SymmetricState {
-    chaining_key: Secret<NOISE_HASHLEN>,
-    token_counter: u8,
+use crate::crypto::aes::{LowThroughputAesGcm, HighThroughputAesGcmPool, AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE};
+use crate::crypto::sha512::{HashSha512, HmacSha512};
+use crate::{applicationlayer::ApplicationLayer, crypto::aes::AES_256_KEY_SIZE};
+use crate::proto::*;
+
+pub struct SymmetricState<App: ApplicationLayer> {
+    k: Zeroizing<[u8; AES_256_KEY_SIZE]>,
+    ck: Zeroizing<[u8; HASHLEN]>,
+    h: [u8; HASHLEN],
+    /// If anyone knows a better way to get rid of the "parameter `App` is never used" error please
+    /// let me know.
+    _app: PhantomData<fn() -> App::SessionData>,
+}
+impl<App: ApplicationLayer> Clone for SymmetricState<App> {
+    fn clone(&self) -> Self {
+        Self {
+            k: self.k.clone(),
+            ck: self.ck.clone(),
+            h: self.h.clone(),
+            _app: PhantomData,
+        }
+    }
 }
 
-impl SymmetricState {
-    pub(crate) fn new(h: [u8; NOISE_HASHLEN]) -> Self {
-        Self { chaining_key: Secret(h), token_counter: b'P' }
-    }
-    /// Corresponds to Noise `MixKey`.
-    pub(crate) fn mix_key(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) {
-        let mut next_ck = Secret::new();
 
-        self.kbkdf(hm, input_key_material, self.label(), 2, next_ck.as_mut(), None, None);
-        self.token_counter += 1;
-
-        self.chaining_key.overwrite(&next_ck);
-        // We don't need a key at this step of Noise, so generating that key and calling
-        // `InitializeKey` would be completely pointless.
-    }
-    /// Corresponds to Noise `MixKey` followed by `InitializeKey`.
-    pub(crate) fn mix_key_initialize_key(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) -> Secret<AES_256_KEY_SIZE> {
-        let mut next_ck = Secret::new();
-        let mut temp_k = [0u8; NOISE_HASHLEN];
-
-        self.kbkdf(hm, input_key_material, self.label(), 2, next_ck.as_mut(), Some(&mut temp_k), None);
-        self.token_counter += 1;
-
-        self.chaining_key.overwrite(&next_ck);
-        Secret::from_bytes_then_delete(&mut temp_k[..AES_256_KEY_SIZE])
-    }
-    /// Corresponds to Noise `MixKeyAndHash`.
-    pub(crate) fn mix_key_and_hash(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) -> [u8; NOISE_HASHLEN] {
-        let mut next_ck = Secret::new();
-        let mut temp_h = [0u8; NOISE_HASHLEN];
-
-        self.kbkdf(hm, input_key_material, self.label(), 3, next_ck.as_mut(), Some(&mut temp_h), None);
-        self.token_counter += 1;
-
-        self.chaining_key.overwrite(&next_ck);
-        temp_h
-    }
-    /// Corresponds to Noise `MixKeyAndHash` followed by `InitializeKey`.
-    pub(crate) fn mix_key_and_hash_initialize_key(
-        &mut self,
-        hm: &mut impl HmacSha512,
-        input_key_material: &[u8],
-    ) -> ([u8; NOISE_HASHLEN], Secret<AES_256_KEY_SIZE>) {
-        let mut next_ck = Secret::new();
-        let mut temp_h = [0u8; NOISE_HASHLEN];
-        let mut temp_k = [0u8; NOISE_HASHLEN];
-
-        self.kbkdf(
-            hm,
-            input_key_material,
-            self.label(),
-            3,
-            next_ck.as_mut(),
-            Some(&mut temp_h),
-            Some(&mut temp_k),
-        );
-        self.token_counter += 1;
-
-        self.chaining_key.overwrite(&next_ck);
-        (temp_h, Secret::from_bytes_then_delete(&mut temp_k[..AES_256_KEY_SIZE]))
-    }
-    /// Get an additional symmetric key (ASK) that is a collision resistant hash of the transcript,
-    /// is forward secrect and is cryptographically independent from all other produced keys.
-    /// Based on Noise's unstable ASK mechanism, using KBKDF instead of HKDF.
-    /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
-    pub(crate) fn get_ask2(
-        &self,
-        hm: &mut impl HmacSha512,
-        label: u8,
-        noise_h: &[u8; NOISE_HASHLEN],
-    ) -> (Secret<AES_256_KEY_SIZE>, Secret<AES_256_KEY_SIZE>) {
-        let mut temp_k1 = [0u8; NOISE_HASHLEN];
-        let mut temp_k2 = [0u8; NOISE_HASHLEN];
-        self.kbkdf(hm, noise_h, [b'A', b'S', b'K', label], 2, &mut temp_k1, Some(&mut temp_k2), None);
-        (
-            Secret::from_bytes_then_delete(&mut temp_k1[..AES_256_KEY_SIZE]),
-            Secret::from_bytes_then_delete(&mut temp_k2[..AES_256_KEY_SIZE]),
-        )
-    }
-    /// Corresponds to Noise `Split`.
-    pub(crate) fn split(self, hm: &mut impl HmacSha512) -> (Secret<AES_256_KEY_SIZE>, Secret<AES_256_KEY_SIZE>) {
-        let mut temp_k1 = [0u8; NOISE_HASHLEN];
-        let mut temp_k2 = [0u8; NOISE_HASHLEN];
-        self.kbkdf(hm, &[], self.label(), 2, &mut temp_k1, Some(&mut temp_k2), None);
-        // Normally KBKDF would not truncate to derive the correct length of AES keys,
-        // but Noise specifies that the AES keys be truncated from NOISE_HASHLEN to AES_256_KEY_SIZE.
-        (
-            Secret::from_bytes_then_delete(&mut temp_k1[..AES_256_KEY_SIZE]),
-            Secret::from_bytes_then_delete(&mut temp_k2[..AES_256_KEY_SIZE]),
-        )
-    }
-    fn label(&self) -> [u8; 4] {
-        [b'Z', b'S', b'S', self.token_counter]
-    }
+impl<App: ApplicationLayer> SymmetricState<App> {
     /// HMAC-SHA512 key derivation based on KBKDF Counter Mode:
     /// https://csrc.nist.gov/publications/detail/sp/800-108/rev-1/final.
     /// Cryptographically this isn't meaningfully different from
@@ -122,36 +40,124 @@ impl SymmetricState {
     /// * L = `num_outputs*512u16`
     /// We have intentionally made every input small and fixed size to avoid unnecessary complexity
     /// and data representation ambiguity.
+    /// Corresponds to Noise `HKDF`.
     fn kbkdf(
         &self,
-        hm: &mut impl HmacSha512,
+        hmac: &mut App::HmacHash,
         input_key_material: &[u8],
-        label: [u8; 4],
+        label: &[u8; 4],
         num_outputs: u16,
-        output1: &mut [u8; NOISE_HASHLEN],
-        output2: Option<&mut [u8; NOISE_HASHLEN]>,
-        output3: Option<&mut [u8; NOISE_HASHLEN]>,
+        output1: &mut [u8; HASHLEN],
+        output2: Option<&mut [u8; HASHLEN]>,
+        output3: Option<&mut [u8; HASHLEN]>,
     ) {
-        let l = &(num_outputs * 512u16).to_be_bytes();
+        const LABEL_START: usize = 1;
+        const LABEL_END: usize = 5;
+        const CONTEXT_START: usize = 6;
+        const LEN_START: usize = 70;
+        const LEN_END: usize = 72;
+        let mut buffer = Zeroizing::new([0u8; LEN_END]);
+        buffer[0] = 1;
+        buffer[LABEL_START..LABEL_END].copy_from_slice(label);
+        buffer[LABEL_END] = 0x00;
+        buffer[CONTEXT_START..LEN_START].copy_from_slice(self.ck.as_ref());
+        buffer[LEN_START..LEN_END].copy_from_slice(&(num_outputs * 8 * HASHLEN as u16).to_be_bytes());
+
+        debug_assert!(num_outputs >= 1);
+        hmac.hash(input_key_material, buffer.as_ref(), output1);
 
-        hm.reset(input_key_material);
-        hm.update(&[1, label[0], label[1], label[2], label[3], 0x00]);
-        hm.update(self.chaining_key.as_ref());
-        hm.update(l);
-        hm.finish(output1);
         if let Some(output2) = output2 {
-            hm.reset(input_key_material);
-            hm.update(&[2, label[0], label[1], label[2], label[3], 0x00]);
-            hm.update(self.chaining_key.as_ref());
-            hm.update(l);
-            hm.finish(output2);
+            debug_assert!(num_outputs >= 2);
+            buffer[0] = 2;
+            hmac.hash(input_key_material, buffer.as_ref(), output2);
         }
+
         if let Some(output3) = output3 {
-            hm.reset(input_key_material);
-            hm.update(&[3, label[0], label[1], label[2], label[3], 0x00]);
-            hm.update(self.chaining_key.as_ref());
-            hm.update(l);
-            hm.finish(output3);
+            debug_assert!(num_outputs >= 3);
+            buffer[0] = 3;
+            hmac.hash(input_key_material, buffer.as_ref(), output3);
         }
     }
+
+    /// Corresponds to Noise `Initialize` on a SymmetricState.
+    pub fn initialize(h: [u8; HASHLEN]) -> Self {
+        Self {
+            k: Zeroizing::default(),
+            ck: Zeroizing::new(h),
+            h,
+            _app: PhantomData,
+        }
+    }
+    /// Corresponds to Noise `MixKey`.
+    pub fn mix_key(&mut self, hmac: &mut App::HmacHash, input_key_material: &[u8]) {
+        let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
+        let mut temp_k = Zeroizing::new([0u8; HASHLEN]);
+
+        self.kbkdf(hmac, input_key_material, LABEL_KBKDF_CHAIN, 2, &mut next_ck, Some(&mut temp_k), None);
+
+        *self.ck = *next_ck;
+        self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
+    }
+    /// Corresponds to Noise `MixHash`.
+    pub fn mix_hash(&mut self, hash: &mut App::Hash, data: &[u8]) {
+        hash.update(&self.h);
+        hash.update(data);
+        hash.finish_and_reset(&mut self.h);
+    }
+    /// Corresponds to Noise `MixKeyAndHash`.
+    pub fn mix_key_and_hash(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, input_key_material: &[u8]) {
+        let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
+        let mut temp_h = [0u8; HASHLEN];
+        let mut temp_k = Zeroizing::new([0u8; HASHLEN]);
+
+        self.kbkdf(
+            hmac,
+            input_key_material,
+            LABEL_KBKDF_CHAIN,
+            3,
+            &mut next_ck,
+            Some(&mut temp_h),
+            Some(&mut temp_k),
+        );
+
+        *self.ck = *next_ck;
+        self.mix_hash(hash, &temp_h);
+        self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
+    }
+    /// Corresponds to Noise `EncryptAndHash`.
+    #[must_use]
+    pub fn encrypt_and_hash_in_place<const CAP: usize>(&mut self, hash: &mut App::Hash, iv: [u8; AES_GCM_IV_SIZE], data: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE] {
+        let tag = App::Aead::encrypt_in_place(&self.k, &iv, &self.h, data);
+        hash.update(&self.h);
+        hash.update(data);
+        hash.update(&tag);
+        hash.finish_and_reset(&mut self.h);
+        tag
+    }
+    /// Corresponds to Noise `DecryptAndHash`.
+    #[must_use]
+    pub fn decrypt_and_hash_in_place(&mut self, hash: &mut App::Hash, iv: [u8; AES_GCM_IV_SIZE], data: &mut [u8], tag: [u8; AES_GCM_TAG_SIZE]) -> bool {
+        hash.update(&self.h);
+        hash.update(data);
+        hash.update(&tag);
+        let is_auth = App::Aead::decrypt_in_place(&self.k, &iv, &self.h, data, tag.as_ref().try_into().unwrap());
+        hash.finish_and_reset(&mut self.h);
+        is_auth
+    }
+    /// Corresponds to Noise `Split`.
+    pub fn split(self, hmac: &mut App::HmacHash, key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
+        self.kbkdf(hmac, &[], LABEL_KBKDF_CHAIN, 2, key1, Some(key2), None);
+    }
+    /// Get an additional symmetric key (ASK) that is a collision resistant hash of the transcript,
+    /// is forward secrect and is cryptographically independent from all other produced keys.
+    /// Based on Noise's unstable ASK mechanism, using KBKDF instead of HKDF.
+    /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
+    pub fn get_ask(&self, hmac: &mut App::HmacHash, label: &[u8; 4], key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
+        self.kbkdf(hmac, &self.h, label, 2, key1, Some(key2), None);
+    }
+    /// Used for internally debugging a key exchange.
+    #[allow(unused)]
+    pub(crate) fn finger(&self) -> (u8, u8, u8) {
+        (self.k[0], self.ck[0], self.h[0])
+    }
 }
diff --git a/src/symmetric_state_old.rs b/src/symmetric_state_old.rs
new file mode 100644
index 0000000..264fc45
--- /dev/null
+++ b/src/symmetric_state_old.rs
@@ -0,0 +1,156 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * (c) ZeroTier, Inc.
+ * https://www.zerotier.com/
+ */
+use crate::crypto::aes::AES_256_KEY_SIZE;
+use crate::crypto::sha512::HmacSha512;
+
+use crate::proto::NOISE_HASHLEN;
+
+#[derive(Clone)]
+pub(crate) struct SymmetricState {
+    chaining_key: Secret<NOISE_HASHLEN>,
+    token_counter: u8,
+}
+
+impl SymmetricState {
+    pub(crate) fn new(h: [u8; NOISE_HASHLEN]) -> Self {
+        Self { chaining_key: Secret(h), token_counter: b'P' }
+    }
+    /// Corresponds to Noise `MixKey`.
+    pub(crate) fn mix_key(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) {
+        let mut next_ck = Secret::new();
+
+        self.kbkdf(hm, input_key_material, self.label(), 2, next_ck.as_mut(), None, None);
+        self.token_counter += 1;
+
+        self.chaining_key.overwrite(&next_ck);
+        // We don't need a key at this step of Noise, so generating that key and calling
+        // `InitializeKey` would be completely pointless.
+    }
+    /// Corresponds to Noise `MixKey` followed by `InitializeKey`.
+    pub(crate) fn mix_key_initialize_key(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) -> Secret<AES_256_KEY_SIZE> {
+        let mut next_ck = Secret::new();
+        let mut temp_k = [0u8; NOISE_HASHLEN];
+
+        self.kbkdf(hm, input_key_material, self.label(), 2, next_ck.as_mut(), Some(&mut temp_k), None);
+        self.token_counter += 1;
+
+        self.chaining_key.overwrite(&next_ck);
+        Secret::from_bytes_then_delete(&mut temp_k[..AES_256_KEY_SIZE])
+    }
+    /// Corresponds to Noise `MixKeyAndHash`.
+    pub(crate) fn mix_key_and_hash(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) -> [u8; NOISE_HASHLEN] {
+        let mut next_ck = Secret::new();
+        let mut temp_h = [0u8; NOISE_HASHLEN];
+
+        self.kbkdf(hm, input_key_material, self.label(), 3, next_ck.as_mut(), Some(&mut temp_h), None);
+        self.token_counter += 1;
+
+        self.chaining_key.overwrite(&next_ck);
+        temp_h
+    }
+    /// Corresponds to Noise `MixKeyAndHash` followed by `InitializeKey`.
+    pub(crate) fn mix_key_and_hash_initialize_key(
+        &mut self,
+        hm: &mut impl HmacSha512,
+        input_key_material: &[u8],
+    ) -> ([u8; NOISE_HASHLEN], Secret<AES_256_KEY_SIZE>) {
+        let mut next_ck = Secret::new();
+        let mut temp_h = [0u8; NOISE_HASHLEN];
+        let mut temp_k = [0u8; NOISE_HASHLEN];
+
+        self.kbkdf(
+            hm,
+            input_key_material,
+            self.label(),
+            3,
+            next_ck.as_mut(),
+            Some(&mut temp_h),
+            Some(&mut temp_k),
+        );
+        self.token_counter += 1;
+
+        self.chaining_key.overwrite(&next_ck);
+        (temp_h, Secret::from_bytes_then_delete(&mut temp_k[..AES_256_KEY_SIZE]))
+    }
+    /// Get an additional symmetric key (ASK) that is a collision resistant hash of the transcript,
+    /// is forward secrect and is cryptographically independent from all other produced keys.
+    /// Based on Noise's unstable ASK mechanism, using KBKDF instead of HKDF.
+    /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
+    pub(crate) fn get_ask2(
+        &self,
+        hm: &mut impl HmacSha512,
+        label: u8,
+        noise_h: &[u8; NOISE_HASHLEN],
+    ) -> (Secret<AES_256_KEY_SIZE>, Secret<AES_256_KEY_SIZE>) {
+        let mut temp_k1 = [0u8; NOISE_HASHLEN];
+        let mut temp_k2 = [0u8; NOISE_HASHLEN];
+        self.kbkdf(hm, noise_h, [b'A', b'S', b'K', label], 2, &mut temp_k1, Some(&mut temp_k2), None);
+        (
+            Secret::from_bytes_then_delete(&mut temp_k1[..AES_256_KEY_SIZE]),
+            Secret::from_bytes_then_delete(&mut temp_k2[..AES_256_KEY_SIZE]),
+        )
+    }
+    /// Corresponds to Noise `Split`.
+    pub(crate) fn split(self, hm: &mut impl HmacSha512) -> (Secret<AES_256_KEY_SIZE>, Secret<AES_256_KEY_SIZE>) {
+        let mut temp_k1 = [0u8; NOISE_HASHLEN];
+        let mut temp_k2 = [0u8; NOISE_HASHLEN];
+        self.kbkdf(hm, &[], self.label(), 2, &mut temp_k1, Some(&mut temp_k2), None);
+        // Normally KBKDF would not truncate to derive the correct length of AES keys,
+        // but Noise specifies that the AES keys be truncated from NOISE_HASHLEN to AES_256_KEY_SIZE.
+        (
+            Secret::from_bytes_then_delete(&mut temp_k1[..AES_256_KEY_SIZE]),
+            Secret::from_bytes_then_delete(&mut temp_k2[..AES_256_KEY_SIZE]),
+        )
+    }
+    fn label(&self) -> [u8; 4] {
+        [b'Z', b'S', b'S', self.token_counter]
+    }
+    /// HMAC-SHA512 key derivation based on KBKDF Counter Mode:
+    /// https://csrc.nist.gov/publications/detail/sp/800-108/rev-1/final.
+    /// Cryptographically this isn't meaningfully different from
+    /// `HKDF(self.chaining_key, input_key_material)` but this is how NIST rolls.
+    /// These are the values we have assigned to the 4 variables involved in their KDF:
+    /// * K_IN = `input_key_material`
+    /// * Label = `label`
+    /// * Context = `self.chaining_key`
+    /// * L = `num_outputs*512u16`
+    /// We have intentionally made every input small and fixed size to avoid unnecessary complexity
+    /// and data representation ambiguity.
+    fn kbkdf(
+        &self,
+        hm: &mut impl HmacSha512,
+        input_key_material: &[u8],
+        label: [u8; 4],
+        num_outputs: u16,
+        output1: &mut [u8; NOISE_HASHLEN],
+        output2: Option<&mut [u8; NOISE_HASHLEN]>,
+        output3: Option<&mut [u8; NOISE_HASHLEN]>,
+    ) {
+        let l = &(num_outputs * 512u16).to_be_bytes();
+
+        hm.reset(input_key_material);
+        hm.update(&[1, label[0], label[1], label[2], label[3], 0x00]);
+        hm.update(self.chaining_key.as_ref());
+        hm.update(l);
+        hm.finish(output1);
+        if let Some(output2) = output2 {
+            hm.reset(input_key_material);
+            hm.update(&[2, label[0], label[1], label[2], label[3], 0x00]);
+            hm.update(self.chaining_key.as_ref());
+            hm.update(l);
+            hm.finish(output2);
+        }
+        if let Some(output3) = output3 {
+            hm.reset(input_key_material);
+            hm.update(&[3, label[0], label[1], label[2], label[3], 0x00]);
+            hm.update(self.chaining_key.as_ref());
+            hm.update(l);
+            hm.finish(output3);
+        }
+    }
+}
diff --git a/src/zeta.rs b/src/zeta.rs
new file mode 100644
index 0000000..159df8b
--- /dev/null
+++ b/src/zeta.rs
@@ -0,0 +1,1394 @@
+use arrayvec::ArrayVec;
+use rand_core::RngCore;
+use std::cmp::Reverse;
+use std::collections::HashMap;
+use std::num::NonZeroU32;
+use std::ops::{Deref, DerefMut};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, Weak, RwLock};
+use zeroize::Zeroizing;
+
+use crate::antireplay::Window;
+use crate::applicationlayer::ApplicationLayer;
+use crate::applicationlayer::RatchetUpdate;
+use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
+use crate::context::ContextInner;
+//use crate::context::{log, ContextInner, SessionMap};
+use crate::crypto::aes::{HighThroughputAesGcmPool, LowThroughputAesGcm, AES_GCM_IV_SIZE, AES_256_KEY_SIZE, AES_GCM_TAG_SIZE};
+use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
+use crate::crypto::sha512::{HashSha512, HmacSha512};
+use crate::crypto::kyber1024::{Kyber1024PrivateKey, KYBER_PUBLIC_KEY_SIZE, KYBER_CIPHERTEXT_SIZE, KYBER_PLAINTEXT_SIZE};
+use crate::indexed_heap::BinaryHeapIndex;
+//use crate::indexed_heap::BinaryHeapIndex;
+//use crate::fragmentation::DefragBuffer;
+use crate::proto::*;
+use crate::ratchet_state::RatchetState;
+use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
+use crate::symmetric_state::SymmetricState;
+#[cfg(feature = "logging")]
+use crate::LogEvent::*;
+
+/// Create a 96-bit AES-GCM nonce.
+///
+/// The primary information that we want to be contained here is the counter and the
+/// packet type. The former makes this unique and the latter's inclusion authenticates
+/// it as effectively AAD. Other elements of the header are either not authenticated,
+/// like fragmentation info, or their authentication is implied via key exchange like
+/// the key id.
+///
+/// Corresponds to Figure 10 found in Section 4.3.
+pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
+    let mut ret = [0u8; AES_GCM_IV_SIZE];
+    ret[3] = packet_type;
+    // Noise requires a big endian counter at the end of the Nonce
+    ret[4..].copy_from_slice(&counter.to_be_bytes());
+    ret
+}
+/// Corresponds to Figure 10 and Figure 14 found in Section 4.3.
+pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
+    assert!(n.len() >= PACKET_NONCE_SIZE);
+    let c_start = n.len() - 8;
+    (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
+}
+fn create_ratchet_state<App: ApplicationLayer>(hmac: &mut App::HmacHash, noise: &mut SymmetricState<App>, pre_chain_len: u64) -> RatchetState {
+    let mut rk = Zeroizing::new([0u8; HASHLEN]);
+    let mut rf = Zeroizing::new([0u8; HASHLEN]);
+    noise.get_ask(hmac, LABEL_RATCHET_STATE, &mut rk, &mut rf);
+    RatchetState::new(Zeroizing::new(rk[..RATCHET_SIZE].try_into().unwrap()), Zeroizing::new(rf[..RATCHET_SIZE].try_into().unwrap()), pre_chain_len + 1)
+}
+
+/// Corresponds to the Zeta State Machine found in Section 4.1.
+pub(crate) struct Session<App: ApplicationLayer> {
+    //ctx: Weak<ContextInner<App>>,
+    /// An arbitrary application defined object associated with each session.
+    pub session_data: App::SessionData,
+    /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
+    pub was_bob: bool,
+    queue_idx: BinaryHeapIndex,
+
+    s_remote: App::PublicKey,
+    send_counter: AtomicU64,
+
+    pub window: Window<COUNTER_WINDOW_MAX_OOO, COUNTER_WINDOW_MAX_SKIP_AHEAD>,
+    //defrag: [Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
+
+    state_machine_lock: Mutex<()>,
+    state: RwLock<MutableState<App>>,
+
+    /// Pre-computed rekeying values.
+    noise_kk_ss: Zeroizing<[u8; P384_ECDH_SHARED_SECRET_SIZE]>,
+}
+pub(crate) struct MutableState<App: ApplicationLayer> {
+    ratchet_state1: RatchetState,
+    ratchet_state2: Option<RatchetState>,
+
+    key_creation_counter: u64,
+    key_index: bool,
+    keys: [DuplexKey<App>; 2],
+    pub hk_send: Zeroizing<[u8; AES_256_KEY_SIZE]>,
+
+    resend_timer: i64,
+    timeout_timer: i64,
+    pub beta: ZetaAutomata<App>,
+}
+
+/// Corresponds to State B_2 of the Zeta State Machine found in Section 4.1 - Definition 3.
+pub(crate) struct StateB2<App: ApplicationLayer> {
+    ratchet_state: RatchetState,
+    kid_send: NonZeroU32,
+    pub kid_recv: NonZeroU32,
+    pub hk_send: Zeroizing<[u8; AES_256_KEY_SIZE]>,
+    e_secret: App::KeyPair,
+    noise: SymmetricState<App>,
+    //pub defrag: DefragBuffer,
+}
+
+#[derive(Default)]
+pub(crate) struct DuplexKey<App: ApplicationLayer> {
+    send: Keys,
+    recv: Keys,
+    nk: Option<App::AeadPool>,
+}
+
+#[derive(Default)]
+pub(crate) struct Keys {
+    kek: Option<Zeroizing<[u8; AES_256_KEY_SIZE]>>,
+    kid: Option<NonZeroU32>,
+}
+
+/// Corresponds to the tuple of values the Transition Algorithms send to the remote peer in Section 4.3.
+//#[derive(Clone)]
+//pub(crate) struct Packet(pub u32, pub [u8; AES_GCM_IV_SIZE], pub Vec<u8>);
+
+/// Corresponds to State A_1 of the Zeta State Machine found in Section 4.1.
+#[derive(Clone)]
+pub(crate) struct StateA1<App: ApplicationLayer> {
+    noise: SymmetricState<App>,
+    e_secret: App::KeyPair,
+    e1_secret: App::Kem,
+    identity: ArrayVec<u8, MAX_IDENTITY_SIZE>,
+    kid_send: u32,
+    nonce: [u8; AES_GCM_IV_SIZE],
+    packet: ArrayVec<u8, HANDSHAKE_HELLO_MAX_SIZE>,
+}
+
+/// Corresponds to the ZKE Automata found in Section 4.1 - Definition 2.
+pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
+    Null,
+    A1(StateA1<App>),
+    A3 {
+        identity: ArrayVec<u8, MAX_IDENTITY_SIZE>,
+        kid_send: u32,
+        nonce: [u8; AES_GCM_IV_SIZE],
+        packet: ArrayVec<u8, HANDSHAKE_COMPLETION_MAX_SIZE>,
+    },
+    S1,
+    S2,
+    R1 {
+        noise: SymmetricState<App>,
+        e_secret: App::KeyPair,
+        k1: Vec<u8>,
+    },
+    R2 {
+        k2: Vec<u8>,
+    },
+}
+
+impl<App: ApplicationLayer> SymmetricState<App> {
+    fn write_e<const CAP: usize>(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, rng: &Mutex<App::Rng>, packet: &mut ArrayVec<u8, CAP>) -> App::KeyPair {
+        let e_secret = App::KeyPair::generate(rng.lock().unwrap().deref_mut());
+        let pub_key = e_secret.public_key_bytes();
+        packet.extend(pub_key);
+        self.mix_hash(hash, &pub_key);
+        self.mix_key(hmac, &pub_key);
+        e_secret
+    }
+    fn read_e<const CAP: usize>(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, i: &mut usize, packet: &[u8]) -> Option<App::PublicKey> {
+        let j = *i + P384_PUBLIC_KEY_SIZE;
+        let pub_key = &packet[*i..j];
+        self.mix_hash(hash, pub_key);
+        self.mix_key(hmac, pub_key);
+        *i = j;
+        App::PublicKey::from_bytes((pub_key).try_into().unwrap())
+    }
+    fn mix_dh(&mut self, hmac: &mut App::HmacHash, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
+        let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
+        if secret.agree(&remote, &mut ecdh_secret) {
+            self.mix_key(hmac, ecdh_secret.as_ref());
+            Some(())
+        } else {
+            None
+        }
+    }
+}
+
+/// Generate a random local key id that is currently unused.
+fn gen_kid<T>(session_map: &HashMap<NonZeroU32, T>, rng: &mut impl RngCore) -> NonZeroU32 {
+    loop {
+        if let Some(kid) = NonZeroU32::new(rng.next_u32()) {
+            if !session_map.contains_key(&kid) {
+                return kid;
+            }
+        }
+    }
+}
+
+impl<App: ApplicationLayer> MutableState<App> {
+    fn key_ref(&self, is_next: bool) -> &DuplexKey<App> {
+        &self.keys[(self.key_index ^ is_next) as usize]
+    }
+    fn key_mut(&mut self, is_next: bool) -> &mut DuplexKey<App> {
+        &mut self.keys[(self.key_index ^ is_next) as usize]
+    }
+    pub(crate) fn next_timer(&self) -> i64 {
+        self.timeout_timer.min(self.resend_timer)
+    }
+}
+
+fn create_a1_state<App: ApplicationLayer>(
+    hash: &mut App::Hash, hmac: &mut App::HmacHash, rng: &Mutex<App::Rng>,
+    s_remote: &App::PublicKey,
+    kid_recv: NonZeroU32,
+    ratchet_state1: &RatchetState,
+    ratchet_state2: Option<&RatchetState>,
+    identity: &[u8],
+) -> Option<StateA1<App>> {
+    //    <- s
+    //    ...
+    //    -> e, es, e1
+    let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_XK);
+    let mut x1 = ArrayVec::<u8, HANDSHAKE_HELLO_MAX_SIZE>::new();
+    // Noise process prologue.
+    let kid = kid_recv.get().to_be_bytes();
+    x1.extend(kid);
+    noise.mix_hash(hash, &kid);
+    noise.mix_hash(hash, &s_remote.to_bytes());
+    // Process message pattern 1 e token.
+    let e_secret = noise.write_e(hash, hmac, rng, &mut x1);
+    // Process message pattern 1 es token.
+    noise.mix_dh(hmac, &e_secret, s_remote)?;
+    // Process message pattern 1 e1 token.
+    let i = x1.len();
+    let (e1_secret, e1_public) = App::Kem::generate(rng.lock().unwrap().deref_mut());
+    x1.extend(e1_public);
+    x1.extend([0u8; AES_GCM_IV_SIZE]);
+    x1.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), &mut x1[i..]));
+    // Process message pattern 1 payload.
+    let i = x1.len();
+    if let Some(rf) = ratchet_state1.fingerprint() {
+        x1.try_extend_from_slice(rf).unwrap();
+    }
+    if let Some(Some(rf)) = ratchet_state2.map(|rs| rs.fingerprint()) {
+        x1.try_extend_from_slice(rf).unwrap();
+    }
+    x1.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 1), &mut x1[i..]));
+
+    let c = u64::from_be_bytes(x1[x1.len() - 8..].try_into().unwrap());
+
+    x1.extend(gen_null_response(rng.lock().unwrap().deref_mut()));
+    Some(StateA1 {
+        noise,
+        e_secret,
+        e1_secret,
+        identity: identity.try_into().unwrap(),
+        kid_send: 0,
+        nonce: to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, c),
+        packet: x1,
+    })
+}
+/// Corresponds to Transition Algorithm 1 found in Section 4.3.
+pub(crate) fn trans_to_a1<App: ApplicationLayer>(
+    app: App,
+    ctx: &Arc<ContextInner<App>>,
+    s_remote: App::PublicKey,
+    session_data: App::SessionData,
+    identity: &[u8],
+    //send: impl FnOnce(&Packet),
+) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
+    let (ratchet_state1, ratchet_state2) = app
+        .restore_by_identity(&s_remote, &session_data)
+        .map_err(|e| OpenError::RatchetIoError(e))?;
+
+    let mut session_queue = ctx.session_queue.lock().unwrap();
+    let mut session_map = ctx.session_map.write().unwrap();
+    let kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
+
+    let hash = &mut App::Hash::new();
+    let hmac = &mut App::HmacHash::new();
+    let a1 = create_a1_state(hash, hmac, &ctx.rng, &s_remote, kid_recv, &ratchet_state1, ratchet_state2.as_ref(), identity).ok_or(OpenError::InvalidPublicKey)?;
+    let packet = a1.packet.clone();
+
+    let mut hk_recv = Zeroizing::new([0u8; HASHLEN]);
+    let mut hk_send = Zeroizing::new([0u8; HASHLEN]);
+    a1.noise.get_ask(hmac, LABEL_HEADER_KEY, &mut hk_recv, &mut hk_send);
+
+    let current_time = app.time();
+    let queue_idx = session_queue.reserve_index();
+    let mut session = Arc::new(Session {
+        session_data,
+        was_bob: false,
+        queue_idx,
+        s_remote,
+        send_counter: AtomicU64::new(0),
+        window: Window::new(),
+        state_machine_lock: Mutex::new(()),
+        state: RwLock::new(MutableState {
+            ratchet_state1,
+            ratchet_state2,
+            key_creation_counter: 0,
+            key_index: true,
+            keys: [DuplexKey::default(), DuplexKey::default()],
+            hk_send: Zeroizing::new(hk_send[..AES_256_KEY_SIZE].try_into().unwrap()),
+            resend_timer: current_time + App::SETTINGS.resend_time as i64,
+            timeout_timer: current_time + App::SETTINGS.initial_offer_timeout as i64,
+            beta: ZetaAutomata::A1(a1),
+        }),
+        noise_kk_ss: Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]),
+    });
+    let mut state = session.state.write().unwrap();
+    state.key_mut(true).recv.kid = Some(kid_recv);
+
+    session_map.insert(kid_recv, Arc::downgrade(&session));
+    session_queue.push_reserved(
+        queue_idx,
+        Arc::downgrade(&session),
+        Reverse(state.next_timer()),
+    );
+
+    //send(&packet);
+
+    Ok(session)
+}
+/// Corresponds to Algorithm 13 found in Section 5.
+//pub(crate) fn respond_to_challenge<App: ApplicationLayer>(zeta: &mut Zeta<App>, rng: &Mutex<App::Rng>, challenge: &[u8; CHALLENGE_SIZE]) {
+//    if let ZetaAutomata::A1(StateA1 { packet: Packet(_, _, x1), .. }) = &mut zeta.beta {
+//        let response_start = x1.len() - CHALLENGE_SIZE;
+//        respond_to_challenge_in_place::<App::Rng, App::Hash>(
+//            rng.lock().unwrap().deref_mut(),
+//            challenge,
+//            (&mut x1[response_start..]).try_into().unwrap(),
+//        );
+//    }
+//}
+/// Corresponds to Transition Algorithm 2 found in Section 4.3.
+pub(crate) fn received_x1_trans<App: ApplicationLayer>(
+    app: &App,
+    ctx: &ContextInner<App>,
+    n: [u8; AES_GCM_IV_SIZE],
+    mut x1: Vec<u8>,
+    //send: impl FnOnce(&Packet, &[u8; AES_256_KEY_SIZE]),
+) -> Result<(), ReceiveError<App::StorageError>> {
+    use FaultType::*;
+    //    <- s
+    //    ...
+    //    -> e, es, e1
+    //    <- e, ee, ekem1, psk
+    if !(HANDSHAKE_HELLO_MIN_SIZE..=HANDSHAKE_HELLO_MAX_SIZE).contains(&x1.len()) {
+        return Err(byzantine_fault!(InvalidPacket, true));
+    }
+    if &n[AES_GCM_IV_SIZE - 8..] != &x1[x1.len() - 8..] {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let hash = &mut App::Hash::new();
+    let hmac = &mut App::HmacHash::new();
+    let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_XK);
+    let mut i = 0;
+    // Noise process prologue.
+    let j = i + KID_SIZE;
+    noise.mix_hash(hash, &x1[i..j]);
+    let kid_send = NonZeroU32::new(u32::from_be_bytes(x1[i..j].try_into().unwrap())).ok_or(byzantine_fault!(InvalidPacket, true))?;
+    noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
+    i = j;
+    // Process message pattern 1 e token.
+    let e_remote = noise.read_e(hash, hmac, &mut i, &x1).ok_or(byzantine_fault!(FailedAuth, true))?;
+    // Process message pattern 1 es token.
+    noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    // Process message pattern 1 e1 token.
+    let j = i + KYBER_PUBLIC_KEY_SIZE;
+    let k = i + AES_GCM_TAG_SIZE;
+    let tag = x1[j..k].try_into().unwrap();
+    if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), &mut x1[i..j], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let e1_start = i;
+    let e1_end = j;
+    i = j;
+    // Process message pattern 1 payload.
+    let k = x1.len();
+    let j = k - AES_GCM_TAG_SIZE;
+    let tag = x1[j..k].try_into().unwrap();
+    if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 1), &mut x1[i..j], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+
+    let mut ratchet_state = None;
+    while i + RATCHET_SIZE <= j {
+        match app.restore_by_fingerprint((&x1[i..i + RATCHET_SIZE]).try_into().unwrap()) {
+            Ok(None) => {}
+            Ok(Some(rs)) => {
+                ratchet_state = Some(rs);
+                break;
+            }
+            Err(e) => return Err(ReceiveError::RatchetIoError(e)),
+        }
+        i += RATCHET_SIZE;
+    }
+    let ratchet_state = if let Some(rs) = ratchet_state {
+        rs
+    } else {
+        if app.hello_requires_recognized_ratchet() {
+            return Err(byzantine_fault!(FailedAuth, true));
+        }
+        RatchetState::empty()
+    };
+    let mut hk_recv = Zeroizing::new([0u8; HASHLEN]);
+    let mut hk_send = Zeroizing::new([0u8; HASHLEN]);
+    noise.get_ask(hmac, LABEL_HEADER_KEY, &mut hk_recv, &mut hk_send);
+
+    let mut x2 = ArrayVec::new();
+    // Process message pattern 2 e token.
+    let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut x2);
+    // Process message pattern 2 ee token.
+    noise.mix_dh(hmac, &e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    // Process message pattern 2 ekem1 token.
+    {
+        let i = x2.len();
+        let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
+        let ekem1 = App::Kem::encapsulate(ctx.rng.lock().unwrap().deref_mut(), (&x1[e1_start..e1_end]).try_into().unwrap(), &mut ekem1_secret).ok_or(byzantine_fault!(FailedAuth, true))?;
+        x2.extend(ekem1);
+        x2.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]));
+        noise.mix_key(hmac, ekem1_secret.as_ref());
+    }
+    // Process message pattern 2 psk2 token.
+    noise.mix_key_and_hash(hash, hmac, ratchet_state.key.as_ref());
+    // Process message pattern 2 payload.
+    let kid_recv = gen_kid(ctx.session_map.read().unwrap().deref(), ctx.rng.lock().unwrap().deref_mut());
+
+    let i = x2.len();
+    x2.extend(kid_recv.get().to_be_bytes());
+    x2.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]));
+
+    let i = x2.len();
+    let mut c = 0u64.to_be_bytes();
+    c[5] = x2[i - 3];
+    c[6] = x2[i - 2];
+    c[7] = x2[i - 1];
+    let c = u64::from_be_bytes(c);
+
+    ///
+    //ctx.b2_map.lock().unwrap().insert(
+    //    kid_recv,
+    //    StateB2 {
+    //        ratchet_state,
+    //        kid_send,
+    //        kid_recv,
+    //        hk_send: hk_send.clone(),
+    //        e_secret,
+    //        noise,
+    //        defrag: DefragBuffer::new(Some(hk_recv)),
+    //    },
+    //);
+
+    //send(&Packet(kid_send.get(), to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, c), x2), &hk_send);
+    Ok(())
+}
+/// Corresponds to Transition Algorithm 3 found in Section 4.3.
+pub(crate) fn received_x2_trans<App: ApplicationLayer>(
+    app: &App,
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
+    kid: NonZeroU32,
+    n: [u8; AES_GCM_IV_SIZE],
+    mut x2: &[u8],
+    //send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+) -> Result<(), ReceiveError<App::StorageError>> {
+    use FaultType::*;
+    //    <- e, ee, ekem1, psk
+    //    -> s, se
+    if HANDSHAKE_RESPONSE_SIZE != x2.len() {
+        return Err(byzantine_fault!(InvalidPacket, true));
+    }
+
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let state = session.state.read().unwrap();
+    let hash = &mut App::Hash::new();
+    let hmac = &mut App::HmacHash::new();
+
+    if Some(kid) != state.key_ref(true).recv.kid {
+        return Err(byzantine_fault!(UnknownLocalKeyId, true));
+    }
+    let (_, c) = from_nonce(&n);
+    if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_IV_SIZE - 3..] != &x2[x2.len() - 3..] {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let result = (|| {
+        if let ZetaAutomata::A1(StateA1 { noise, e_secret, e1_secret, identity, .. }) = &state.beta {
+            let mut noise = noise.clone();
+            let mut i = 0;
+            // Process message pattern 2 e token.
+            let e_remote = noise.read_e(hash, hmac, &mut i, &x2).ok_or(byzantine_fault!(FailedAuth, true))?;
+            // Process message pattern 2 ee token.
+            noise.mix_dh(hmac, e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            // Process message pattern 2 ekem1 token.
+            let j = i + KYBER_CIPHERTEXT_SIZE;
+            let k = j + AES_GCM_TAG_SIZE;
+            let tag = x2[j..k].try_into().unwrap();
+            if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..j], tag) {
+                return Err(byzantine_fault!(FailedAuth, true));
+            }
+            let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
+            if !e1_secret.decapsulate((&x2[i..j]).try_into().unwrap(), &mut ekem1_secret) {
+                return Err(byzantine_fault!(FailedAuth, true));
+            }
+            noise.mix_key(hmac, ekem1_secret.as_ref());
+            drop(ekem1_secret);
+            i = j;
+            // We attempt to decrypt the payload at most three times. First two times with
+            // the ratchet key Alice remembers, and final time with a ratchet
+            // key of zero if Alice allows ratchet downgrades.
+            // The following code is not constant time, meaning we leak to an
+            // attacker whether or not we downgraded.
+            // We don't currently consider this sensitive enough information to hide.
+            let j = i + KID_SIZE;
+            let k = j + AES_GCM_TAG_SIZE;
+            let payload: [u8; KID_SIZE] = x2[i..j].try_into().unwrap();
+            let tag = x2[j..k].try_into().unwrap();
+            // Check for which ratchet key Bob wants to use.
+            let test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState<App>)> {
+                let mut noise = noise.clone();
+                let mut payload = payload.clone();
+                // Process message pattern 2 psk token.
+                noise.mix_key_and_hash(hash, hmac, ratchet_key);
+                // Process message pattern 2 payload.
+                if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut payload, tag) {
+                    return None;
+                }
+                NonZeroU32::new(u32::from_be_bytes(payload)).map(|kid2| (kid2, noise))
+            };
+            // Check first key.
+            let mut ratchet_i = 1;
+            let mut chain_len = state.ratchet_state1.chain_len;
+            let mut result = test_ratchet_key(state.ratchet_state1.key.as_ref());
+            // Check second key.
+            if result.is_none() {
+                ratchet_i = 2;
+                if let Some(rs) = state.ratchet_state2.as_ref() {
+                    chain_len = rs.chain_len;
+                    result = test_ratchet_key(rs.key.as_ref());
+                }
+            }
+            // Check zero key.
+            if result.is_none() && !app.initiator_disallows_downgrade(session) {
+                chain_len = 0;
+                result = test_ratchet_key(&[0u8; RATCHET_SIZE]);
+                if result.is_some() {
+                    // TODO: add some kind of warning callback or signal.
+                }
+            }
+
+            let (kid_send, mut noise) = result.ok_or(byzantine_fault!(FailedAuth, true))?;
+            let mut x3 = ArrayVec::new();
+
+            // Process message pattern 3 s token.
+            let i = x3.len();
+            x3.extend(ctx.s_secret.public_key_bytes());
+            x3.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..]));
+            // Process message pattern 3 se token.
+            noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            // Process message pattern 3 payload.
+            let i = x3.len();
+            x3.try_extend_from_slice(identity).unwrap();
+            x3.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), &mut x3[i..]));
+
+            let new_ratchet_state = create_ratchet_state(hmac, &mut noise, chain_len);
+
+            let (ratchet_to_preserve, ratchet_to_delete) = if ratchet_i == 1 {
+                (Some(&state.ratchet_state1), state.ratchet_state2.as_ref())
+            } else {
+                (state.ratchet_state2.as_ref(), Some(&state.ratchet_state1))
+            };
+            let result = app.save_ratchet_state(
+                &session.s_remote,
+                &session.session_data,
+                RatchetUpdate {
+                    state1: &new_ratchet_state,
+                    state2: ratchet_to_preserve,
+                    state1_was_just_added: true,
+                    state_deleted1: ratchet_to_delete,
+                    state_deleted2: None,
+                },
+            );
+            if let Err(e) = result {
+                return Err(ReceiveError::RatchetIoError(e));
+            }
+
+            let kek_recv = Zeroizing::new([0u8; HASHLEN]);
+            let kek_send = Zeroizing::new([0u8; HASHLEN]);
+            let nk_recv = Zeroizing::new([0u8; HASHLEN]);
+            let nk_send = Zeroizing::new([0u8; HASHLEN]);
+            noise.get_ask(hmac, LABEL_KEX_KEY, &mut kek_recv, &mut kek_send);
+            noise.split(hmac, &mut nk_recv, &mut nk_send);
+            let nonce = to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0);
+
+            //let identity = identity.clone();
+            drop(state);
+            let mut state = session.state.write().unwrap();
+
+            state.key_mut(true).send.kid = Some(kid_send);
+            state.key_mut(true).send.kek = Some(Zeroizing::new(kek_send[..AES_256_KEY_SIZE].try_into().unwrap()));
+            state.key_mut(true).recv.kek = Some(Zeroizing::new(kek_recv[..AES_256_KEY_SIZE].try_into().unwrap()));
+            state.key_mut(true).nk = Some(App::AeadPool::new((&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap(), (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()));
+            state.ratchet_state2 = Some(state.ratchet_state1.clone());
+            state.ratchet_state1 = new_ratchet_state.clone();
+            let current_time = app.time();
+            state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
+            state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            state.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
+            state.beta = ZetaAutomata::A3 { identity: identity.clone(), packet: x3, kid_send: kid_send.get(), nonce };
+
+            Ok(())
+        } else {
+            Err(byzantine_fault!(FailedAuth, true))
+        }
+    })();
+    match &result {
+        Err(ReceiveError::ByzantineFault { .. }) => timeout_trans(state, session, app, ctx, app.time(), send),
+        Ok(packet) => send(packet, Some(&state.hk_send)),
+        _ => {}
+    }
+    result.map(|_| ())
+}
+/// Corresponds to Transition Algorithm 4 found in Section 4.3.
+pub(crate) fn received_x3_trans<App: ApplicationLayer>(
+    zeta: StateB2<App>,
+    app: &App,
+    ctx: &Arc<ContextInner<App>>,
+    kid: NonZeroU32,
+    mut x3: Vec<u8>,
+    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+) -> Result<Arc<Session<App>>, ReceiveError<App::StorageError>> {
+    use FaultType::*;
+    //    -> s, se
+    if x3.len() < HANDSHAKE_COMPLETION_MIN_SIZE {
+        return Err(byzantine_fault!(InvalidPacket, true));
+    }
+    if kid != zeta.kid_recv {
+        return Err(byzantine_fault!(UnknownLocalKeyId, true));
+    }
+
+    let mut noise = zeta.noise.clone();
+    let mut i = 0;
+    // Process message pattern 3 s token.
+    let j = i + P384_PUBLIC_KEY_SIZE;
+    let k = j + AES_GCM_TAG_SIZE;
+    let tag = x3[j..k].try_into().unwrap();
+    if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..j], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let s_remote = App::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
+    i = k;
+    // Process message pattern 3 se token.
+    noise.mix_dh(&zeta.e_secret, &s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    // Process message pattern 3 payload.
+    let k = x3.len();
+    let j = k - AES_GCM_TAG_SIZE;
+    let tag = x3[j..k].try_into().unwrap();
+    if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), &mut x3[i..j], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let identity_start = i;
+    let identity_end = j;
+
+    let (kek_send, kek_recv) = noise.get_ask(LABEL_KEX_KEY);
+    let c = INIT_COUNTER;
+
+    let action = app.check_accept_session(&s_remote, &x3[identity_start..identity_end]);
+    let responder_disallows_downgrade = action.responder_disallows_downgrade;
+    let responder_silently_rejects = action.responder_silently_rejects;
+    let session_data = action.session_data;
+    let create_reject = || {
+        let mut d = Vec::<u8>::new();
+        let n = to_nonce(PACKET_TYPE_SESSION_REJECTED, c);
+        let tag = App::Aead::encrypt_in_place(&kek_send, n, None, &mut []);
+        d.extend(&tag);
+        // We just used a counter with this key, but we are not storing
+        // the fact we used it in memory. This is currently ok because the
+        // handshake is being dropped, so nonce reuse can't happen.
+        Packet(zeta.kid_send.get(), n, d)
+    };
+    if let Some(session_data) = session_data {
+        let result = app.restore_by_identity(&s_remote, &session_data);
+        match result {
+            Ok((ratchet_state1, ratchet_state2)) => {
+                if (&zeta.ratchet_state != &ratchet_state1) & (Some(&zeta.ratchet_state) != ratchet_state2.as_ref()) {
+                    if !responder_disallows_downgrade && zeta.ratchet_state.fingerprint().is_none() {
+                        // TODO: add some kind of warning callback or signal.
+                    } else {
+                        if !responder_silently_rejects {
+                            send(&create_reject(), Some(&zeta.hk_send))
+                        }
+                        return Err(byzantine_fault!(FailedAuth, true));
+                    }
+                }
+
+                let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
+                // We must make sure the ratchet key is saved before we transition.
+                let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state.chain_len + 1);
+                let result = app.save_ratchet_state(
+                    &s_remote,
+                    &session_data,
+                    RatchetUpdate {
+                        state1: &new_ratchet_state,
+                        state2: None,
+                        state1_was_just_added: true,
+                        state_deleted1: Some(&ratchet_state1),
+                        state_deleted2: ratchet_state2.as_ref(),
+                    },
+                );
+                if let Err(e) = result {
+                    return Err(ReceiveError::RatchetIoError(e));
+                }
+
+                let mut c1 = Vec::new();
+                let n = to_nonce(PACKET_TYPE_KEY_CONFIRM, c);
+                let tag = App::Aead::encrypt_in_place(&kek_send, n, None, &mut []);
+                c1.extend(&tag);
+
+                let (nk1, nk2) = noise.split();
+                let keys = DuplexKey {
+                    send: Keys { kek: Some(kek_send), nk: Some(nk1), kid: Some(zeta.kid_send) },
+                    recv: Keys { kek: Some(kek_recv), nk: Some(nk2), kid: Some(zeta.kid_recv) },
+                };
+                let current_time = app.time();
+
+                let mut session_map = ctx.session_map.lock().unwrap();
+                use std::collections::hash_map::Entry::*;
+                let entry = match session_map.entry(zeta.kid_recv) {
+                    // We could have issued the kid that we initially offered Alice to someone else
+                    // before Alice was able to respond. It is unlikely but possible.
+                    Occupied(_) => return Err(byzantine_fault!(OutOfSequence, false)),
+                    Vacant(entry) => entry,
+                };
+                let session = Arc::new(Session(Mutex::new(Zeta {
+                    ctx: Arc::downgrade(ctx),
+                    session_data,
+                    was_bob: true,
+                    s_remote,
+                    send_counter: INIT_COUNTER + 1,
+                    key_creation_counter: INIT_COUNTER + 1,
+                    key_index: false,
+                    keys: [keys, DuplexKey::default()],
+                    ratchet_state1: new_ratchet_state,
+                    ratchet_state2: None,
+                    hk_send: zeta.hk_send.clone(),
+                    resend_timer: current_time + App::SETTINGS.resend_time as i64,
+                    timeout_timer: current_time + App::SETTINGS.rekey_timeout as i64,
+                    beta: ZetaAutomata::S1,
+                    counter_antireplay_window: std::array::from_fn(|_| 0),
+                    defrag: zeta.defrag,
+                })));
+                entry.insert(Arc::downgrade(&session));
+                ctx.sessions.lock().unwrap().insert(Arc::as_ptr(&session), Arc::downgrade(&session));
+
+                send(&Packet(zeta.kid_send.get(), n, c1), Some(&zeta.hk_send));
+                Ok(session)
+            }
+            Err(e) => Err(ReceiveError::RatchetIoError(e)),
+        }
+    } else {
+        if !responder_silently_rejects {
+            send(&create_reject(), Some(&zeta.hk_send))
+        }
+        Err(byzantine_fault!(FailedAuth, true))
+    }
+}
+/// Corresponds to Transition Algorithm 5 found in Section 4.3.
+pub(crate) fn received_c1_trans<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    app: &App,
+    rng: &Mutex<App::Rng>,
+    kid: NonZeroU32,
+    n: [u8; AES_GCM_IV_SIZE],
+    c1: Vec<u8>,
+    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+) -> Result<bool, ReceiveError<App::StorageError>> {
+    use FaultType::*;
+
+    if c1.len() != KEY_CONFIRMATION_SIZE {
+        return Err(byzantine_fault!(InvalidPacket, true));
+    }
+    let is_other = if Some(kid) == zeta.key_ref(true).recv.kid {
+        true
+    } else if Some(kid) == zeta.key_ref(false).recv.kid {
+        false
+    } else {
+        // Some key confirmation may have arrived extremely delayed.
+        // It is unlikely but possible.
+        return Err(byzantine_fault!(OutOfSequence, false));
+    };
+
+    let specified_key = zeta.key_ref(is_other).recv.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let tag = c1[..].try_into().unwrap();
+    if !App::Aead::decrypt_in_place(specified_key, n, None, &mut [], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let (_, c) = from_nonce(&n);
+    if !zeta.update_counter_window(c) {
+        return Err(byzantine_fault!(ExpiredCounter, true));
+    }
+
+    let just_establised = is_other && matches!(&zeta.beta, ZetaAutomata::A3 { .. });
+    if is_other {
+        if let ZetaAutomata::A3 { .. } | ZetaAutomata::R2 { .. } = &zeta.beta {
+            if zeta.ratchet_state2.is_some() {
+                let result = app.save_ratchet_state(
+                    &zeta.s_remote,
+                    &zeta.session_data,
+                    RatchetUpdate {
+                        state1: &zeta.ratchet_state1,
+                        state2: None,
+                        state1_was_just_added: false,
+                        state_deleted1: zeta.ratchet_state2.as_ref(),
+                        state_deleted2: None,
+                    },
+                );
+                if let Err(e) = result {
+                    return Err(ReceiveError::RatchetIoError(e));
+                }
+            }
+
+            zeta.ratchet_state2 = None;
+            zeta.key_index ^= true;
+            zeta.timeout_timer = app.time()
+                + App::SETTINGS
+                    .rekey_after_time
+                    .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+            zeta.resend_timer = i64::MAX;
+            zeta.beta = ZetaAutomata::S2;
+        }
+    }
+    let mut c2 = Vec::new();
+
+    let c = zeta.send_counter;
+    zeta.send_counter += 1;
+    let n = to_nonce(PACKET_TYPE_ACK, c);
+    let latest_confirmed_key = zeta.key_ref(false).send.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let tag = App::Aead::encrypt_in_place(latest_confirmed_key, n, None, &mut []);
+    c2.extend(&tag);
+
+    send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c2), Some(&zeta.hk_send));
+    Ok(just_establised)
+}
+/// Corresponds to the trivial Transition Algorithm described for processing C_2 packets found in
+/// Section 4.3.
+pub(crate) fn received_c2_trans<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    app: &App,
+    rng: &Mutex<App::Rng>,
+    kid: NonZeroU32,
+    n: [u8; AES_GCM_IV_SIZE],
+    c2: Vec<u8>,
+) -> Result<(), ReceiveError<App::StorageError>> {
+    use FaultType::*;
+
+    if c2.len() != ACKNOWLEDGEMENT_SIZE {
+        return Err(byzantine_fault!(InvalidPacket, true));
+    }
+    if Some(kid) != zeta.key_ref(false).recv.kid {
+        // Some acknowledgement may have arrived extremely delayed.
+        return Err(byzantine_fault!(UnknownLocalKeyId, false));
+    }
+    if !matches!(&zeta.beta, ZetaAutomata::S1) {
+        // Some acknowledgement may have arrived extremely delayed.
+        return Err(byzantine_fault!(OutOfSequence, false));
+    }
+
+    let tag = c2[..].try_into().unwrap();
+    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), n, None, &mut [], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let (_, c) = from_nonce(&n);
+    if !zeta.update_counter_window(c) {
+        return Err(byzantine_fault!(ExpiredCounter, true));
+    }
+
+    zeta.timeout_timer = app.time()
+        + App::SETTINGS
+            .rekey_after_time
+            .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+    zeta.resend_timer = i64::MAX;
+    zeta.beta = ZetaAutomata::S2;
+    Ok(())
+}
+/// Corresponds to the trivial Transition Algorithm described for processing D packets found in
+/// Section 4.3.
+pub(crate) fn received_d_trans<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    kid: NonZeroU32,
+    n: [u8; AES_GCM_IV_SIZE],
+    d: Vec<u8>,
+) -> Result<(), ReceiveError<App::StorageError>> {
+    use FaultType::*;
+
+    if d.len() != SESSION_REJECTED_SIZE {
+        return Err(byzantine_fault!(InvalidPacket, true));
+    }
+    if Some(kid) != zeta.key_ref(true).recv.kid || !matches!(&zeta.beta, ZetaAutomata::A3 { .. }) {
+        return Err(byzantine_fault!(OutOfSequence, true));
+    }
+
+    let tag = d[..].try_into().unwrap();
+    if !App::Aead::decrypt_in_place(zeta.key_ref(true).recv.kek.as_ref().unwrap(), n, None, &mut [], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let (_, c) = from_nonce(&n);
+    if !zeta.update_counter_window(c) {
+        return Err(byzantine_fault!(ExpiredCounter, true));
+    }
+
+    zeta.expire();
+    Ok(())
+}
+/// Corresponds to the timer rules of the Zeta State Machine found in Section 4.1 - Definition 3.
+pub(crate) fn service<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    session: &Arc<Session<App>>,
+    ctx: &Arc<ContextInner<App>>,
+    app: &App,
+    current_time: i64,
+    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+) {
+    if zeta.timeout_timer <= current_time {
+        timeout_trans(zeta, session, app, ctx, current_time, send);
+    } else if zeta.resend_timer <= current_time {
+        // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
+        zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+
+        let (p, mut control_payload) = match &zeta.beta {
+            ZetaAutomata::Null => return,
+            ZetaAutomata::A1(StateA1 { packet, .. }) => {
+                log!(app, ResentX1(session));
+                return send(packet, None);
+            }
+            ZetaAutomata::A3 { packet, .. } => {
+                log!(app, ResentX3(session));
+                return send(packet, Some(&zeta.hk_send));
+            }
+            ZetaAutomata::S1 => {
+                log!(app, ResentKeyConfirm(session));
+                (PACKET_TYPE_KEY_CONFIRM, Vec::new())
+            }
+            ZetaAutomata::S2 => return,
+            ZetaAutomata::R1 { k1, .. } => {
+                log!(app, ResentK1(session));
+                (PACKET_TYPE_REKEY_INIT, k1.clone())
+            }
+            ZetaAutomata::R2 { k2, .. } => {
+                log!(app, ResentK2(session));
+                (PACKET_TYPE_REKEY_COMPLETE, k2.clone())
+            }
+        };
+        let c = zeta.send_counter;
+        zeta.send_counter += 1;
+        let n = to_nonce(p, c);
+        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut control_payload);
+        control_payload.extend(&tag);
+        send(
+            &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, control_payload),
+            Some(&zeta.hk_send),
+        );
+    }
+}
+fn remap<App: ApplicationLayer>(session: &Arc<Session<App>>, zeta: &Zeta<App>, rng: &Mutex<App::Rng>, session_map: &SessionMap<App>) -> NonZeroU32 {
+    let mut session_map = session_map.lock().unwrap();
+    let weak = if let Some(Some(weak)) = zeta.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
+        weak
+    } else {
+        Arc::downgrade(&session)
+    };
+    let new_kid_recv = gen_kid(session_map.deref(), rng.lock().unwrap().deref_mut());
+    session_map.insert(new_kid_recv, weak);
+    new_kid_recv
+}
+/// Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
+fn timeout_trans<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    session: &Arc<Session<App>>,
+    app: &App,
+    ctx: &Arc<ContextInner<App>>,
+    current_time: i64,
+    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+) {
+    match &zeta.beta {
+        ZetaAutomata::Null => {}
+        ZetaAutomata::A1(StateA1 { identity, .. }) | ZetaAutomata::A3 { identity, .. } => {
+            if matches!(&zeta.beta, ZetaAutomata::A1(_)) {
+                log!(app, TimeoutX1(session));
+            } else {
+                log!(app, TimeoutX3(session));
+            }
+            let new_kid_recv = remap(session, &zeta, &ctx.rng, &ctx.session_map);
+
+            if let Some(a1) = create_a1_state(
+                &ctx.rng,
+                &zeta.s_remote,
+                new_kid_recv,
+                &zeta.ratchet_state1,
+                zeta.ratchet_state2.as_ref(),
+                identity.clone(),
+            ) {
+                let (hk_recv, hk_send) = a1.noise.get_ask(LABEL_HEADER_KEY);
+                let packet = a1.packet.clone();
+
+                zeta.hk_send = hk_send;
+                *zeta.key_mut(true) = DuplexKey::default();
+                zeta.key_mut(true).recv.kid = Some(new_kid_recv);
+                zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                zeta.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
+                zeta.beta = ZetaAutomata::A1(a1);
+                zeta.defrag = DefragBuffer::new(Some(hk_recv));
+
+                send(&packet, None);
+            } else {
+                zeta.expire();
+            }
+        }
+        ZetaAutomata::S2 => {
+            // Corresponds to Transition Algorithm 6 found in Section 4.3.
+            log!(app, StartedRekeyingSentK1(session));
+            let new_kid_recv = remap(session, &zeta, &ctx.rng, &ctx.session_map);
+            //    -> s
+            //    <- s
+            //    ...
+            //    -> psk, e, es, ss
+            let mut k1 = Vec::new();
+            let mut noise = SymmetricState::initialize(PROTOCOL_NAME_NOISE_KK);
+            // Noise process prologue.
+            noise.mix_hash(&ctx.s_secret.public_key_bytes());
+            noise.mix_hash(&zeta.s_remote.to_bytes());
+            // Process message pattern 1 psk0 token.
+            noise.mix_key_and_hash(zeta.ratchet_state1.key.as_ref());
+            // Process message pattern 1 e token.
+            let e_secret = noise.write_e(&ctx.rng, &mut k1);
+            // Process message pattern 1 es token.
+            if noise.mix_dh(&e_secret, &zeta.s_remote).is_none() {
+                zeta.expire();
+                return;
+            }
+            // Process message pattern 1 ss token.
+            if noise.mix_dh(&ctx.s_secret, &zeta.s_remote).is_none() {
+                zeta.expire();
+                return;
+            }
+            // Process message pattern 1 payload.
+            let i = k1.len();
+            k1.extend(&new_kid_recv.get().to_be_bytes());
+            noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_INIT, 0), i, &mut k1);
+
+            zeta.key_mut(true).recv.kid = Some(new_kid_recv);
+            zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
+            zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            zeta.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
+
+            let c = zeta.send_counter;
+            zeta.send_counter += 1;
+            let n = to_nonce(PACKET_TYPE_REKEY_INIT, c);
+            let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k1);
+            k1.extend(&tag);
+
+            send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k1), Some(&zeta.hk_send));
+        }
+        ZetaAutomata::S1 { .. } => {
+            log!(app, TimeoutKeyConfirm(session));
+            zeta.expire();
+        }
+        ZetaAutomata::R1 { .. } => {
+            log!(app, TimeoutK1(session));
+            zeta.expire();
+        }
+        ZetaAutomata::R2 { .. } => {
+            log!(app, TimeoutK2(session));
+            zeta.expire();
+        }
+    }
+}
+/// Corresponds to Transition Algorithm 7 found in Section 4.3.
+pub(crate) fn received_k1_trans<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    session: &Arc<Session<App>>,
+    app: &App,
+    rng: &Mutex<App::Rng>,
+    session_map: &SessionMap<App>,
+    s_secret: &App::KeyPair,
+    kid: NonZeroU32,
+    n: [u8; AES_GCM_IV_SIZE],
+    mut k1: Vec<u8>,
+    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+) -> Result<(), ReceiveError<App::StorageError>> {
+    use FaultType::*;
+    //    -> s
+    //    <- s
+    //    ...
+    //    -> psk, e, es, ss
+    //    <- e, ee, se
+    if k1.len() != REKEY_SIZE {
+        return Err(byzantine_fault!(InvalidPacket, true));
+    }
+    if Some(kid) != zeta.key_ref(false).recv.kid {
+        // Some rekey packet may have arrived extremely delayed.
+        return Err(byzantine_fault!(UnknownLocalKeyId, false));
+    }
+    let should_rekey_as_bob = match &zeta.beta {
+        ZetaAutomata::S2 { .. } => true,
+        ZetaAutomata::R1 { .. } => zeta.was_bob,
+        _ => false,
+    };
+    if !should_rekey_as_bob {
+        // Some rekey packet may have arrived extremely delayed.
+        return Err(byzantine_fault!(OutOfSequence, false));
+    }
+
+    let i = k1.len() - AES_GCM_TAG_SIZE;
+    let tag = k1[i..].try_into().unwrap();
+    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), n, None, &mut k1[..i], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let (_, c) = from_nonce(&n);
+    if !zeta.update_counter_window(c) {
+        return Err(byzantine_fault!(ExpiredCounter, true));
+    }
+    k1.truncate(i);
+
+    let result = (|| {
+        let mut i = 0;
+        let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_KK);
+        // Noise process prologue.
+        noise.mix_hash(&zeta.s_remote.to_bytes());
+        noise.mix_hash(&s_secret.public_key_bytes());
+        // Process message pattern 1 psk0 token.
+        noise.mix_key_and_hash(zeta.ratchet_state1.key.as_ref());
+        // Process message pattern 1 e token.
+        let e_remote = noise.read_e(&mut i, &k1).ok_or(byzantine_fault!(FailedAuth, true))?;
+        // Process message pattern 1 es token.
+        noise.mix_dh(s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        // Process message pattern 1 ss token.
+        noise.mix_dh(s_secret, &zeta.s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        // Process message pattern 1 payload.
+        let j = i + KID_SIZE;
+        let k = j + AES_GCM_TAG_SIZE;
+        let tag = k1[j..k].try_into().unwrap();
+        if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..j], tag) {
+            return Err(byzantine_fault!(FailedAuth, true));
+        }
+        let kid_send = NonZeroU32::new(u32::from_be_bytes(k1[i..j].try_into().unwrap())).ok_or(byzantine_fault!(FailedAuth, true))?;
+
+        let mut k2 = Vec::new();
+        // Process message pattern 2 e token.
+        let e_secret = noise.write_e(rng, &mut k2);
+        // Process message pattern 2 ee token.
+        noise.mix_dh(&e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        // Process message pattern 2 se token.
+        noise.mix_dh(&s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        // Process message pattern 2 payload.
+        let i = k2.len();
+        let new_kid_recv = remap(session, &zeta, rng, session_map);
+        k2.extend(&new_kid_recv.get().to_be_bytes());
+        noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), i, &mut k2);
+
+        let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
+        let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
+        let result = app.save_ratchet_state(
+            &zeta.s_remote,
+            &zeta.session_data,
+            RatchetUpdate {
+                state1: &new_ratchet_state,
+                state2: Some(&zeta.ratchet_state1),
+                state1_was_just_added: true,
+                state_deleted1: zeta.ratchet_state2.as_ref(),
+                state_deleted2: None,
+            },
+        );
+        if let Err(e) = result {
+            return Err(ReceiveError::RatchetIoError(e));
+        }
+        let (kek_send, kek_recv) = noise.get_ask(LABEL_KEX_KEY);
+        let (nk_send, nk_recv) = noise.split();
+
+        zeta.key_mut(true).send.kid = Some(kid_send);
+        zeta.key_mut(true).send.kek = Some(kek_send);
+        zeta.key_mut(true).send.nk = Some(nk_send);
+        zeta.key_mut(true).recv.kid = Some(new_kid_recv);
+        zeta.key_mut(true).recv.kek = Some(kek_recv);
+        zeta.key_mut(true).recv.nk = Some(nk_recv);
+        zeta.ratchet_state2 = Some(zeta.ratchet_state1.clone());
+        zeta.ratchet_state1 = new_ratchet_state;
+        let current_time = app.time();
+        zeta.key_creation_counter = zeta.send_counter;
+        zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
+        zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+        zeta.beta = ZetaAutomata::R2 { k2: k2.clone() };
+
+        let c = zeta.send_counter;
+        zeta.send_counter += 1;
+        let n = to_nonce(PACKET_TYPE_REKEY_COMPLETE, c);
+        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k2);
+        k2.extend(&tag);
+
+        send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k2), Some(&zeta.hk_send));
+        Ok(())
+    })();
+    if matches!(result, Err(ReceiveError::ByzantineFault { .. })) {
+        zeta.expire();
+    }
+    result
+}
+/// Corresponds to Transition Algorithm 8 found in Section 4.3.
+pub(crate) fn received_k2_trans<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    app: &App,
+    kid: NonZeroU32,
+    n: [u8; AES_GCM_IV_SIZE],
+    mut k2: Vec<u8>,
+    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+) -> Result<(), ReceiveError<App::StorageError>> {
+    use FaultType::*;
+    //    <- e, ee, se
+    if k2.len() != REKEY_SIZE {
+        return Err(byzantine_fault!(InvalidPacket, true));
+    }
+    if Some(kid) != zeta.key_ref(false).recv.kid {
+        // Some rekey packet may have arrived extremely delayed.
+        return Err(byzantine_fault!(UnknownLocalKeyId, false));
+    }
+    if !matches!(&zeta.beta, ZetaAutomata::R1 { .. }) {
+        // Some rekey packet may have arrived extremely delayed.
+        return Err(byzantine_fault!(OutOfSequence, false));
+    }
+
+    let i = k2.len() - AES_GCM_TAG_SIZE;
+    let tag = k2[i..].try_into().unwrap();
+    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), n, None, &mut k2[..i], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let (_, c) = from_nonce(&n);
+    if !zeta.update_counter_window(c) {
+        return Err(byzantine_fault!(ExpiredCounter, true));
+    }
+    k2.truncate(i);
+    let result = (|| {
+        if let ZetaAutomata::R1 { noise, e_secret, .. } = &zeta.beta {
+            let mut noise = noise.clone();
+            let mut i = 0;
+            // Process message pattern 2 e token.
+            let e_remote = noise.read_e(&mut i, &k2).ok_or(byzantine_fault!(FailedAuth, true))?;
+            // Process message pattern 2 ee token.
+            noise.mix_dh(e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            // Process message pattern 2 se token.
+            noise.mix_dh(e_secret, &zeta.s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            // Process message pattern 2 payload.
+            let j = i + KID_SIZE;
+            let k = j + AES_GCM_TAG_SIZE;
+            let tag = k2[j..k].try_into().unwrap();
+            if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..j], tag) {
+                return Err(byzantine_fault!(FailedAuth, true));
+            }
+            let kid_send = NonZeroU32::new(u32::from_be_bytes(k2[i..j].try_into().unwrap())).ok_or(byzantine_fault!(InvalidPacket, true))?;
+
+            let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
+            let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
+            let result = app.save_ratchet_state(
+                &zeta.s_remote,
+                &zeta.session_data,
+                RatchetUpdate {
+                    state1: &new_ratchet_state,
+                    state2: None,
+                    state1_was_just_added: true,
+                    state_deleted1: Some(&zeta.ratchet_state1),
+                    state_deleted2: zeta.ratchet_state2.as_ref(),
+                },
+            );
+            if let Err(e) = result {
+                return Err(ReceiveError::RatchetIoError(e));
+            }
+            let (kek_recv, kek_send) = noise.get_ask(LABEL_KEX_KEY);
+            let (nk_recv, nk_send) = noise.split();
+
+            zeta.key_mut(true).send.kid = Some(kid_send);
+            zeta.key_mut(true).send.kek = Some(kek_send);
+            zeta.key_mut(true).send.nk = Some(nk_send);
+            zeta.key_mut(true).recv.kek = Some(kek_recv);
+            zeta.key_mut(true).recv.nk = Some(nk_recv);
+            zeta.ratchet_state1 = new_ratchet_state;
+            zeta.key_index ^= true;
+            let current_time = app.time();
+            zeta.key_creation_counter = zeta.send_counter;
+            zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
+            zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            zeta.beta = ZetaAutomata::S1;
+
+            let mut c1 = Vec::new();
+            let c = zeta.send_counter;
+            zeta.send_counter += 1;
+            let n = to_nonce(PACKET_TYPE_KEY_CONFIRM, c);
+            let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut []);
+            c1.extend(&tag);
+
+            send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c1), Some(&zeta.hk_send));
+            Ok(())
+        } else {
+            unreachable!()
+        }
+    })();
+    if matches!(result, Err(ReceiveError::ByzantineFault { .. })) {
+        zeta.expire();
+    }
+    result
+}
+/// Corresponds to Algorithm 9 found in Section 4.3.
+pub(crate) fn send_payload<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    mut payload: Vec<u8>,
+    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+) -> Result<(), SendError> {
+    use SendError::*;
+
+    if matches!(&zeta.beta, ZetaAutomata::Null) {
+        return Err(SessionExpired);
+    }
+    if !matches!(
+        &zeta.beta,
+        ZetaAutomata::S1 | ZetaAutomata::S2 | ZetaAutomata::R1 { .. } | ZetaAutomata::R2 { .. }
+    ) {
+        return Err(SessionNotEstablished);
+    }
+    let c = zeta.send_counter;
+    zeta.send_counter += 1;
+    if c >= zeta.key_creation_counter + App::SETTINGS.rekey_after_key_uses {
+        if c >= zeta.key_creation_counter + EXPIRE_AFTER_USES {
+            zeta.expire();
+        } else {
+            // Cause timeout to occur next service interval.
+            zeta.timeout_timer = i64::MIN;
+        }
+    }
+
+    let n = to_nonce(PACKET_TYPE_DATA, c);
+    let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.nk.as_ref().unwrap(), n, None, &mut payload);
+    payload.extend(&tag);
+
+    send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, payload), Some(&zeta.hk_send));
+    Ok(())
+}
+/// Corresponds to Algorithm 10 found in Section 4.3.
+pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
+    zeta: &mut Zeta<App>,
+    kid: NonZeroU32,
+    n: [u8; AES_GCM_IV_SIZE],
+    payload: &mut Vec<u8>,
+) -> Result<(), ReceiveError<App::StorageError>> {
+    use FaultType::*;
+
+    if payload.len() < AES_GCM_TAG_SIZE {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let is_other = if Some(kid) == zeta.key_ref(true).recv.kid {
+        true
+    } else if Some(kid) == zeta.key_ref(false).recv.kid {
+        false
+    } else {
+        // A packet would have to be delayed by around an hour for this error to occur, but it can
+        // occur naturally due to just out-of-order transport.
+        return Err(byzantine_fault!(OutOfSequence, false));
+    };
+
+    let i = payload.len() - AES_GCM_TAG_SIZE;
+    let specified_key = zeta.key_ref(is_other).recv.nk.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let tag = payload[i..].try_into().unwrap();
+    if !App::Aead::decrypt_in_place(specified_key, n, None, &mut payload[..i], tag) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+    let (_, c) = from_nonce(&n);
+    if !zeta.update_counter_window(c) {
+        // This error is marked as not happening naturally, but it could occur if something about
+        // the transport protocol is duplicating packets.
+        return Err(byzantine_fault!(ExpiredCounter, true));
+    }
+    payload.truncate(i);
+
+    Ok(())
+}
+
+impl<App: ApplicationLayer> Session<App> {
+    /// Mark a session as expired. This will make it impossible for this session to successfully
+    /// receive or send data or control packets. It is recommended to simply `drop` the session
+    /// instead, but this can provide some reassurance in complex shared ownership situations.
+    pub fn expire(&mut self) {
+        self.0.lock().unwrap().expire();
+    }
+}
+
+impl<App: ApplicationLayer> Drop for Session<App> {
+    fn drop(&mut self) {
+        self.expire();
+    }
+}
diff --git a/src/zssp copy.rs b/src/zssp copy.rs
new file mode 100644
index 0000000..413c38d
--- /dev/null
+++ b/src/zssp copy.rs	
@@ -0,0 +1,2704 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at https://mozilla.org/MPL/2.0/.
+*
+* (c) ZeroTier, Inc.
+* https://www.zerotier.com/
+*/
+// ZSSP: ZeroTier Secure Session Protocol
+// FIPS compliant Noise_XK with Jedi powers (Kyber1024) and built-in attack-resistant large payload (fragmentation) support.
+
+use std::cmp::Reverse;
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::num::{NonZeroU32, NonZeroU64};
+use std::ops::DerefMut;
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, MutexGuard, RwLock, Weak};
+
+use crate::crypto::aes::{AesDec, AesEnc};
+use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
+use crate::crypto::pqc_kyber::KYBER_SECRETKEYBYTES;
+use crate::crypto::rand_core::RngCore;
+use crate::crypto::sha512::{HmacSha512, HashSha512};
+
+use crate::error::{FaultType, OpenError, ReceiveError, SendError};
+use crate::frag_cache::UnassociatedFragCache;
+use crate::fragged::{Assembled, Fragged};
+use crate::handshake_cache::UnassociatedHandshakeCache;
+use crate::indexed_heap::{BinaryHeapIndex, IndexedBinaryHeap};
+use crate::log_event::LogEvent;
+use crate::proto::*;
+use crate::symmetric_state::SymmetricState;
+use crate::{applicationlayer::*, RatchetState};
+
+/// Session context for local application.
+///
+/// Each application using ZSSP must create an instance of this to own sessions and
+/// defragment incoming packets that are not yet associated with a session.
+///
+/// Internally this is just a clonable Arc, so it can be safely shared with multiple threads.
+pub struct Context<Application: ApplicationLayer>(pub Arc<ContextInner<Application>>);
+impl<Application: ApplicationLayer> Clone for Context<Application> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+pub struct ContextInner<Application: ApplicationLayer> {
+    static_keypair: Application::KeyPair,
+    unassociated_defrag_cache: Mutex<UnassociatedFragCache<Application::IncomingPacketBuffer>>,
+    unassociated_handshake_states: UnassociatedHandshakeCache<Application>,
+    /// `session_queue -> state_machine_lock -> state -> session_map`
+    session_queue: Mutex<IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>>,
+    session_map: RwLock<HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>>,
+    challenge_counter: AtomicU64,
+    challenge_antireplay_window: [AtomicU64; CHALLENGE_COUNTER_WINDOW_MAX_OOO],
+    challenge_salt: [u8; CHALLENGE_SALT_SIZE],
+    rng: Mutex<Application::Rng>,
+}
+
+/// Result generated by the context packet receive function, with possible payloads.
+pub enum ReceiveResult<'b, Application: ApplicationLayer> {
+    /// Packet superficially appeared valid but is not associated with a session yet.
+    /// This can occur because the packet was only a fragment of a larger packet,
+    /// or if it was a control packet that does not go through full Noise authentication.
+    Unassociated,
+    /// Packet was authentic and belongs to this specific session.
+    Session(Arc<Session<Application>>, SessionEvent<'b>),
+    /// Packet was a part of a handshake, and while it superficially appeared valid the application
+    /// explicitly rejected it.
+    /// Relates to callbacks `check_allow_incoming_session`, `hello_requires_recognized_ratchet`
+    /// and `check_accept_session`.
+    Rejected,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum SessionEvent<'b> {
+    /// The received packet was valid, and it contained the necessary keys to fully establish a new
+    /// session with Alice, the handshake initiator.
+    ///
+    /// If the session Arc returned is dropped, the session with this peer will be immediately
+    /// terminated. Save the session Arc to some long lived datastructure to keep it alive.
+    NewSession,
+    /// When Alice calls `Context::open`, a session will be created, but Bob will not yet have
+    /// received this session. They will have to successfully complete a handshake first.
+    ///
+    /// Alice will receive this return value when the received packet confirms both parties
+    /// have completed the initial handshake and now have a shared session with each other.
+    /// If according to the upper protocol, Bob is the first party to send data, it is possible for
+    /// Alice to start receiving data from Bob before this value is returned.
+    ///
+    /// This return value can only occur once per session, only for session objects that were
+    /// created with `Context::open`.
+    Established,
+    /// Bob explicitly refused to establish a session with Alice, and sent us an error code.
+    /// The application should immediately drop this session as Bob will not allow us to connect.
+    ///
+    /// This return value cannot occur after a session is fully established.
+    Rejected,
+    /// The received packet was valid and a data payload was decoded and authenticated.
+    Data(&'b mut [u8]),
+    /// The received packet was some authentic protocol control packet. No action needs to be taken.
+    Control,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum IncomingSessionAction {
+    Allow,
+    Challenge,
+    Drop,
+}
+
+/// ZeroTier Secure Session Protocol (ZSSP) Session
+///
+/// A FIPS/NIST compliant variant of Noise_XK with hybrid Kyber1024 PQ data forward secrecy.
+pub struct Session<Application: ApplicationLayer> {
+    /// An arbitrary application defined object associated with each session.
+    pub application_data: Application::SessionData,
+    /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
+    pub was_bob: bool,
+    /// The receive context associated with this session,
+    /// only this context can receive messages from the remote peer.
+    context: Weak<ContextInner<Application>>,
+    /// Handle into the session queue for changing the update timer.
+    queue_idx: BinaryHeapIndex,
+
+    remote_static_key: Application::PublicKey,
+    send_counter: AtomicU64,
+    /// This bool signals to all threads to stop incrementing the counter and instead error out.
+    session_has_expired: AtomicBool,
+    /// The following is a ring buffer of previously seen counter values, where we use the counter's
+    /// value as the index of the head of the ring buffer.
+    counter_antireplay_window: [AtomicU64; COUNTER_WINDOW_MAX_OOO],
+    /// Enforces atomicity of state machine transitions.
+    /// There is a standard locking sequence,
+    /// it goes `session_queue -> state_machine_lock -> state -> session_map`.
+    /// Any lock can be skipped but they must be locked in that order.
+    state_machine_lock: Mutex<()>,
+    state: RwLock<SessionMutableState<Application>>,
+    defrag: [Mutex<Fragged<Application::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
+    header_send_cipher: Application::PrpEnc,
+    header_receive_cipher: Application::PrpDec,
+    kex_send_cipher: Mutex<Option<Application::AeadEnc>>,
+    kex_receive_cipher: Mutex<Option<Application::AeadDec>>,
+    /// Pre-computed rekeying values.
+    noise_kk_ss: Secret<P384_ECDH_SHARED_SECRET_SIZE>,
+    noise_kk_local_init_h: [u8; HASHLEN],
+    noise_kk_remote_init_h: [u8; HASHLEN],
+}
+/// `AesGcm` is not threadsafe, but it is threadsafe when inside a `Mutex`.
+unsafe impl<Application: ApplicationLayer> Send for Session<Application> {}
+unsafe impl<Application: ApplicationLayer> Sync for Session<Application> {}
+
+/// Session state may only be mutated during atomic transitions of the offer state machine.
+struct SessionMutableState<Application: ApplicationLayer> {
+    ratchet_states: [RatchetState; 2],
+    /// For OOO rekeying reliability we allow our version of Noise CipherState to hold the last two
+    /// session keys, instead of just the most recent one.
+    cipher_states: [Option<SessionKey<Application>>; 2],
+    /// This is the index of `noise_cipher_state` that contains the most recent key.
+    /// It will be attached to fragment headers to help with OOO transport.
+    current_key: usize,
+    /// This defines the exact state of the offer state machine we are in.
+    outgoing_offer: OfferStateMachine<Application>,
+}
+
+/// These offer enums form a state machine.
+/// Documented below are the only legal transitions for this state machine.
+/// A session is initialized with an `outgoing_offer` of either NoiseXKPattern1 or Normal.
+enum OfferStateMachine<Application: ApplicationLayer> {
+    Normal {
+        timeout: i64,
+    }, // -> NoiseKKPattern1, NoiseKKPattern2
+    /// This state uses a lot of memory so we put it on the heap.
+    NoiseXKPattern1or3(Box<NoiseXKAliceHandshake<Application>>), // -> Normal
+    NoiseKKPattern1 {
+        next_retry_time: AtomicI64,
+        timeout: i64,
+        new_key_id: NonZeroU32,
+        noise_e_secret: Application::KeyPair,
+        noise_message: [u8; NoiseKKPattern1or2::SIZE],
+        noise_ck: SymmetricState,
+        noise_h_pskep: [u8; HASHLEN],
+    }, // -> NoiseKKPattern2, KeyConfirm
+    NoiseKKPattern2 {
+        next_retry_time: AtomicI64,
+        timeout: i64,
+        noise_message: [u8; NoiseKKPattern1or2::SIZE],
+        kex_send_key: Secret<AES_GCM_KEY_SIZE>,
+    }, // -> Normal
+    KeyConfirm {
+        next_retry_time: AtomicI64,
+        timeout: i64,
+    }, // -> Normal
+    Null,
+}
+
+pub(crate) struct NoiseXKBobHandshakeState<Application: ApplicationLayer> {
+    /// Can never be Null.
+    ratchet_state: RatchetState,
+    remote_key_id: NonZeroU32,
+    local_key_id: NonZeroU32,
+    header_receive_key: Secret<AES_GCM_KEY_SIZE>,
+    header_send_key: Secret<AES_GCM_KEY_SIZE>,
+    noise_h_ee1peekem1pskp: [u8; HASHLEN],
+    noise_e_secret: Application::KeyPair,
+    noise_ck_eseeekem1psk: SymmetricState,
+    noise_k_eseeekem1psk: Secret<AES_GCM_KEY_SIZE>,
+    noise_pattern3_defrag: Mutex<Fragged<Application::IncomingPacketBuffer, MAX_FRAGMENTS>>,
+}
+
+struct NoiseXKAliceHandshake<Application: ApplicationLayer> {
+    next_retry_time: AtomicI64,
+    timeout: i64,
+    /// A secure random number put in the header of Alice's fragments to identify them.
+    /// If a DDOS attacker could guess this they could block Alice starting the handshake.
+    local_key_id: NonZeroU32,
+    alice_identity_blob: Application::LocalIdentityBlob,
+    offer: NoiseXKAliceHandshakeState<Application>,
+}
+
+enum NoiseXKAliceHandshakeState<Application: ApplicationLayer> {
+    NoiseXKPattern1 {
+        noise_h_ee1p: [u8; HASHLEN],
+        noise_e_secret: Application::KeyPair,
+        noise_e1_secret: Secret<KYBER_SECRETKEYBYTES>,
+        noise_ck_es: SymmetricState,
+        /// ZSSP assumes an unreliable, out-of-order physical transport environment, so for that
+        /// reason we have to resend key offers.
+        noise_message: [u8; NoiseXKPattern1::MAX_SIZE],
+        noise_message_len: usize,
+        message_id: u64,
+    },
+    NoiseXKPattern3 {
+        noise_message: [u8; NoiseXKPattern3::MAX_SIZE],
+        noise_message_len: usize,
+    },
+}
+
+struct SessionKey<Application: ApplicationLayer> {
+    remote_key_id: NonZeroU32,
+    local_key_id: NonZeroU32,
+    /// Pool of reusable sending ciphers.
+    receive_cipher_pool: [Mutex<Application::AeadDec>; 8],
+    /// Pool of reusable receiving ciphers.
+    send_cipher_pool: [Mutex<Application::AeadEnc>; 8],
+    /// Rekey at or after this counter.
+    rekey_at_counter: u64,
+    /// Hard error when this counter value is reached or exceeded.
+    expire_at_counter: u64,
+}
+
+macro_rules! byzantine_fault {
+    ($name:expr, $is_natural:ident) => {
+        ReceiveError::ByzantineFault {
+            file: file!(),
+            line: line!(),
+            error: $name,
+            is_naturally_occurring: $is_natural,
+        }
+    };
+}
+
+impl<Application: ApplicationLayer> Context<Application> {
+    /// Create a new session context.
+    pub fn new(static_keypair: Application::KeyPair, mut rng: Application::Rng) -> Self {
+        debug_assert!(Application::REKEY_AFTER_TIME_MAX_JITTER_MS > 0, "Invalid protocol constant");
+        let mut challenge_salt = [0u8; CHALLENGE_SALT_SIZE];
+        rng.fill_bytes(&mut challenge_salt);
+        Self(Arc::new(ContextInner {
+            static_keypair,
+            unassociated_defrag_cache: Mutex::new(UnassociatedFragCache::new()),
+            unassociated_handshake_states: UnassociatedHandshakeCache::new(),
+            session_map: RwLock::new(HashMap::new()),
+            session_queue: Mutex::new(IndexedBinaryHeap::new()),
+            challenge_counter: AtomicU64::new(INIT_COUNTER),
+            challenge_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
+            challenge_salt,
+            rng: Mutex::new(rng),
+        }))
+    }
+
+    /// Perform periodic background service and cleanup tasks.
+    ///
+    /// This returns the number of milliseconds until it should be called again. The caller should
+    /// try to satisfy this but small variations in timing of up to +/- a second or two are not
+    /// a problem.
+    ///
+    /// * `send_to` - Function to get a sender and an MTU to send something over an active session
+    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
+    ///   with remote peers (although both of these properties would help reliability slightly).
+    ///   Used to determine if any current handshakes should be resent or timed-out, or if a session
+    ///   should rekey.
+    pub fn service<SendFn: FnMut(&mut [u8]) -> bool>(
+        &self,
+        app: &Application,
+        mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
+        current_time: i64,
+    ) -> i64 {
+        let retry_next = current_time.saturating_add(Application::RETRY_INTERVAL_MS);
+        let mut next_service_time = 2 * Application::RETRY_INTERVAL_MS;
+
+        let mut session_queue = self.0.session_queue.lock().unwrap();
+        // This update system takes heavy advantage of the fact that sessions only need to be updated
+        // either roughly every second or roughly every hour. That big gap allows for minor optimizations.
+        // If the gap changes (unlikely) this code may need to be rewritten.
+        while let Some((session, timer, queue_idx)) = session_queue.peek() {
+            if timer.0 >= current_time {
+                next_service_time = next_service_time.min(timer.0 - current_time);
+                break;
+            }
+            let session = match session.upgrade() {
+                Some(s) => s,
+                _ => {
+                    session_queue.remove(queue_idx);
+                    continue;
+                }
+            };
+            let state = session.state.read().unwrap();
+            use OfferStateMachine::*;
+            let next_timer = match &state.outgoing_offer {
+                Normal { timeout, .. } => {
+                    if *timeout <= current_time {
+                        drop(state);
+                        if let Some((send, _)) = send_to(&session) {
+                            let result = initiate_rekey(&self.0, &session, send, current_time);
+                            if result.is_ok() {
+                                app.event_log(LogEvent::ServiceKKStart(&session), current_time);
+                            }
+                            result.unwrap_or(retry_next)
+                        } else {
+                            retry_next
+                        }
+                    } else {
+                        *timeout
+                    }
+                }
+                // If there's an outstanding attempt to open a session, retransmit this
+                // periodically in case the initial packet doesn't make it.
+                NoiseXKPattern1or3(handshake_state) => {
+                    if let Some(ts) = process_timer(&handshake_state.next_retry_time, Application::RETRY_INTERVAL_MS, current_time) {
+                        ts
+                    } else {
+                        // We have to eventually time out NoiseXKPattern3 because of unreliable network conditions.
+                        if handshake_state.timeout <= current_time {
+                            drop(state);
+                            let _kex_lock = session.state_machine_lock.lock().unwrap();
+                            let mut state = session.state.write().unwrap();
+                            let ratchet_state = state.ratchet_states.clone();
+                            // Since we dropped the lock we must re-check if we are in the correct state.
+                            if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
+                                if handshake_state.timeout <= current_time {
+                                    app.event_log(LogEvent::ServiceXKTimeout(&session), current_time);
+                                    handshake_state.reinitialize(
+                                        &session,
+                                        &ratchet_state,
+                                        &mut self.0.session_map.write().unwrap(),
+                                        &mut self.0.rng.lock().unwrap(),
+                                        current_time,
+                                    );
+                                }
+                            }
+                        } else if let Some((mut send, mut mtu)) = send_to(&session) {
+                            mtu = mtu.max(MIN_TRANSPORT_MTU);
+                            match &handshake_state.offer {
+                                NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, message_id, .. } => {
+                                    app.event_log(LogEvent::ServiceXK1Resend(&session), current_time);
+                                    // We are in state NoiseXKPattern1 so resend noise_pattern1.
+                                    send_with_fragmentation(
+                                        &mut send,
+                                        mtu,
+                                        &mut noise_message.clone()[..*noise_message_len],
+                                        PACKET_TYPE_NOISE_XK_PATTERN_1,
+                                        None,
+                                        *message_id,
+                                        None::<&Application::PrpEnc>,
+                                    );
+                                }
+                                NoiseXKAliceHandshakeState::NoiseXKPattern3 { noise_message, noise_message_len, .. } => {
+                                    app.event_log(LogEvent::ServiceXK3Resend(&session), current_time);
+                                    send_with_fragmentation(
+                                        &mut send,
+                                        mtu,
+                                        &mut noise_message.clone()[..*noise_message_len],
+                                        PACKET_TYPE_NOISE_XK_PATTERN_3,
+                                        state.cipher_states[0].as_ref().map(|k| k.remote_key_id),
+                                        0,
+                                        Some(&session.header_send_cipher),
+                                    );
+                                }
+                            }
+                        }
+                        retry_next
+                    }
+                }
+                NoiseKKPattern1 { next_retry_time, timeout, noise_message, .. } | NoiseKKPattern2 { next_retry_time, timeout, noise_message, .. } => {
+                    if let Some(ts) = process_timer(next_retry_time, Application::RETRY_INTERVAL_MS, current_time) {
+                        ts
+                    } else {
+                        if *timeout <= current_time {
+                            app.event_log(LogEvent::ServiceKKTimeout(&session), current_time);
+                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
+                            drop(state);
+                            session.expire_inner(&self.0, &mut session_queue);
+                        } else {
+                            let packet_type = if let NoiseKKPattern1 { .. } = &state.outgoing_offer {
+                                app.event_log(LogEvent::ServiceKK1Resend(&session), current_time);
+                                PACKET_TYPE_NOISE_KK_PATTERN_1
+                            } else {
+                                app.event_log(LogEvent::ServiceKK2Resend(&session), current_time);
+                                PACKET_TYPE_NOISE_KK_PATTERN_2
+                            };
+                            if let Some((send, _)) = send_to(&session) {
+                                let _ = session.send_control(&state, send, packet_type, noise_message);
+                            }
+                        }
+                        retry_next
+                    }
+                }
+                KeyConfirm { next_retry_time, timeout, .. } => {
+                    if let Some(ts) = process_timer(next_retry_time, Application::RETRY_INTERVAL_MS, current_time) {
+                        ts
+                    } else {
+                        if *timeout <= current_time {
+                            app.event_log(LogEvent::ServiceKeyConfirmTimeout(&session), current_time);
+                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
+                            drop(state);
+                            session.expire_inner(&self.0, &mut session_queue);
+                        } else {
+                            app.event_log(LogEvent::ServiceKeyConfirmResend(&session), current_time);
+                            if let Some((send, _)) = send_to(&session) {
+                                let _ = session.send_control(&state, send, PACKET_TYPE_KEY_CONFIRM, &[]);
+                            }
+                        }
+                        retry_next
+                    }
+                }
+                Null => retry_next,
+            };
+            session_queue.change_priority(queue_idx, Reverse(next_timer));
+        }
+        drop(session_queue);
+
+        self.0
+            .unassociated_defrag_cache
+            .lock()
+            .unwrap()
+            .check_for_expiry(Application::INITIAL_OFFER_TIMEOUT_MS, current_time);
+        self.0.unassociated_handshake_states.service(current_time);
+
+        next_service_time
+    }
+
+    /// Create a new session and send initial packet(s) to other side.
+    ///
+    /// This will return SendError::DataTooLarge if the combined size of the metadata and the local
+    /// static public blob (as retrieved from the application layer) exceed MAX_INIT_PAYLOAD_SIZE.
+    ///
+    /// * `app` - Application layer instance
+    /// * `send` - Function to be called to send one or more initial packets to the remote being
+    ///   contacted
+    /// * `mtu` - MTU for initial packets
+    /// * `remote_static_key` - Remote side's static public NIST P-384 key
+    /// * `application_data` - Arbitrary data meaningful to the application to include with session
+    ///   object
+    /// * `ratchet_state` - The last saved and confirmed ratchet state associated with this remote
+    ///   peer, or None if we do not have one.
+    /// * `local_identity_blob` - Payload to be sent to Bob that contains the information necessary
+    ///   for the upper protocol to authenticate and approve of Alice's identity.
+    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
+    /// with the remote peer. Used to determine when this offer should be resent.
+    pub fn open(
+        &self,
+        app: &Application,
+        mut send: impl FnMut(&mut [u8]) -> bool,
+        mut mtu: usize,
+        remote_static_key: Application::PublicKey,
+        application_data: Application::SessionData,
+        local_identity_blob: Application::LocalIdentityBlob,
+        current_time: i64,
+    ) -> Result<Arc<Session<Application>>, OpenError<Application::StorageError>> {
+        mtu = mtu.max(MIN_TRANSPORT_MTU);
+        if local_identity_blob.as_ref().len() > MAX_IDENTITY_BLOB_SIZE {
+            return Err(OpenError::DataTooLarge);
+        }
+        let result = app.restore_by_identity(&remote_static_key, &application_data, current_time);
+        match result {
+            Ok(ratchet_states) => {
+                let sha512 = &mut Application::Hash::new();
+
+                let mut noise_kk_ss = Secret::new();
+                if !self.0.static_keypair.agree(&remote_static_key, noise_kk_ss.as_mut()) {
+                    return Err(OpenError::InvalidPublicKey);
+                }
+                let noise_kk_local_init_h = mix_hash(sha512, &INITIAL_H_REKEY, self.0.static_keypair.public_key_bytes());
+                let noise_kk_local_init_h = mix_hash(sha512, &noise_kk_local_init_h, remote_static_key.as_bytes());
+                let noise_kk_remote_init_h = mix_hash(sha512, &INITIAL_H_REKEY, remote_static_key.as_bytes());
+                let noise_kk_remote_init_h = mix_hash(sha512, &noise_kk_remote_init_h, self.0.static_keypair.public_key_bytes());
+
+                let mut session_queue = self.0.session_queue.lock().unwrap();
+                let mut session_map = self.0.session_map.write().unwrap();
+                let local_key_id = generate_key_id(&session_map, &mut self.0.rng.lock().unwrap());
+                // Begin Noise XKhfs+psk2.
+                let (offer, a2b_header_key, b2a_header_key) = NoiseXKAliceHandshake::<Application>::initialize(
+                    local_key_id,
+                    &remote_static_key,
+                    &ratchet_states,
+                    &mut self.0.rng.lock().unwrap(),
+                )?;
+                let handshake_state = Box::new(NoiseXKAliceHandshake {
+                    next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
+                    timeout: current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS),
+                    local_key_id,
+                    alice_identity_blob: local_identity_blob,
+                    offer,
+                });
+                if let NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, message_id, .. } = &handshake_state.offer {
+                    send_with_fragmentation(
+                        &mut send,
+                        mtu,
+                        &mut noise_message.clone()[..*noise_message_len],
+                        PACKET_TYPE_NOISE_XK_PATTERN_1,
+                        None,
+                        *message_id,
+                        None::<&Application::PrpEnc>,
+                    );
+                }
+
+                let queue_idx = session_queue.reserve_index();
+                let session = Arc::new(Session {
+                    context: Arc::downgrade(&self.0),
+                    queue_idx,
+                    application_data,
+                    remote_static_key,
+                    send_counter: AtomicU64::new(INIT_COUNTER),
+                    session_has_expired: AtomicBool::new(false),
+                    counter_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
+                    state_machine_lock: Mutex::new(()),
+                    state: RwLock::new(SessionMutableState {
+                        ratchet_states: ratchet_states.clone(),
+                        cipher_states: [None, None],
+                        // Points at 1 until the first key is confirmed.
+                        current_key: 1,
+                        outgoing_offer: OfferStateMachine::NoiseXKPattern1or3(handshake_state),
+                    }),
+                    header_send_cipher: Application::PrpEnc::new(a2b_header_key.as_ref()),
+                    header_receive_cipher: Application::PrpDec::new(b2a_header_key.as_ref()),
+                    kex_receive_cipher: Mutex::new(None),
+                    kex_send_cipher: Mutex::new(None),
+                    noise_kk_ss: noise_kk_ss.clone(),
+                    noise_kk_local_init_h,
+                    noise_kk_remote_init_h,
+                    defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
+                    was_bob: false,
+                });
+                session_map.insert(local_key_id, (Arc::downgrade(&session), false));
+                session_queue.push_reserved(
+                    queue_idx,
+                    Arc::downgrade(&session),
+                    Reverse(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
+                );
+
+                Ok(session)
+            }
+            Err(e) => Err(OpenError::RatchetIoError(e)),
+        }
+    }
+
+    /// Receive, authenticate, decrypt, and process a physical wire packet.
+    ///
+    /// The check_allow_incoming_session function is called when an initial Noise_XK init message is
+    /// received. This is before anything is known about the caller. A return value of true proceeds
+    /// with negotiation. False drops the packet and ignores the inbound attempt.
+    ///
+    /// The check_accept_session function is called at the end of negotiation for an incoming
+    /// session with the caller's static public blob. It must return the P-384 static public key
+    /// extracted from the supplied blob and application data. A return of Some() accepts the
+    /// session and will always result in a new session ReceiveResult being returned.
+    ///
+    /// * `app` - Interface to application using ZSSP
+    /// * `check_allow_incoming_session` - Function to call to check whether an unidentified new
+    ///   session should be accepted
+    /// * `check_accept_session` - Function to accept sessions after final negotiation.
+    ///   The second argument is the identity blob that the remote peer sent us. The application
+    ///   must verify this identity is associated with the remote peer's static key.
+    ///   The third argument is the ratchet chain length, or ratchet count.
+    ///   To prevent desync, if this function returns (Some(_), _), no other open session with the
+    ///   same remote peer must exist.
+    /// * `send_unassociated_reply` - Function to send reply packets directly when no session exists
+    /// * `send_unassociated_mtu` - MTU for unassociated replies
+    /// * `send_to` - Function to get senders for existing sessions, permitting MTU and path lookup
+    /// * `remote_address` - Whatever the remote address is, as long as you can Hash it
+    /// * `data_buf` - Buffer to receive decrypted and authenticated object data (an error is
+    ///   returned if too small)
+    /// * `incoming_physical_packet_buf` - Buffer containing incoming wire packet
+    ///   (receive() takes ownership)
+    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
+    ///   with the remote peer. Used to check the state of local offers we may currently have or want
+    ///   to put in-flight.
+    pub fn receive<'a, SendFn: FnMut(&mut [u8]) -> bool>(
+        &self,
+        app: &Application,
+        check_allow_incoming_session: impl FnOnce() -> IncomingSessionAction,
+        check_accept_session: impl FnOnce(&Application::PublicKey, &[u8], u64) -> (Option<(bool, Application::SessionData)>, bool),
+        mut send_unassociated_reply: impl FnMut(&mut [u8]) -> bool,
+        mut send_unassociated_mtu: usize,
+        mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
+        remote_address: &impl Hash,
+        data_buf: &'a mut [u8],
+        mut incoming_physical_packet_buf: Application::IncomingPacketBuffer,
+        current_time: i64,
+    ) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::StorageError>> {
+        send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
+        let incoming_physical_packet: &mut [u8] = incoming_physical_packet_buf.as_mut();
+        let incoming_physical_packet_len = incoming_physical_packet.len();
+        if incoming_physical_packet_len < MIN_PACKET_SIZE {
+            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+        }
+
+        // The first section parses the header and looks up relevant state information. If it's a DATA
+        // or NOP packet it gets handled right here, otherwise we pull out a set of variables and
+        // continue to the logic that handles KEX and session control packets.
+
+        let mut assembled_packet = Assembled::new(); // needs to outlive the block below
+        let mut incoming = None;
+        let (session, packet_type, fragments) = {
+            let local_key_id = incoming_physical_packet[0..SESSION_ID_SIZE].try_into().unwrap();
+            // `from_ne_bytes` because this id was generated locally.
+            if let Some(local_key_id) = NonZeroU32::new(u32::from_ne_bytes(local_key_id)) {
+                let session_map = self.0.session_map.read().unwrap();
+                if let Some((Some(session), key_index)) = session_map.get(&local_key_id).map(|r| (r.0.upgrade(), r.1 as usize)) {
+                    drop(session_map);
+                    session.header_receive_cipher.decrypt_in_place(
+                        (&mut incoming_physical_packet[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END])
+                            .try_into()
+                            .unwrap(),
+                    );
+                    let (fragment_count, fragment_no, packet_type, incoming_counter, header_nonce) = parse_packet_header(incoming_physical_packet);
+                    // Handle replay protection.
+                    if PACKET_TYPE_RANGE_TRANSPORT.contains(&packet_type) {
+                        // For DOS resistant reply-protection we need to check that the given counter is
+                        // in the window of valid counters immediately.
+                        // But for packets larger than 1 fragment we can't actually record the
+                        // counter as received until we've authenticated the packet.
+                        // So we check the counter window twice, and only update it the second time
+                        // after the packet has been authenticated.
+                        if !session.check_receive_window(incoming_counter) {
+                            // This can occur naturally if packets arrive way out of order, or
+                            // if they are duplicates.
+                            // This can also be naturally triggered if Bob has just successfully
+                            // received the first session key and is reject all of Alice's resends.
+                            // This can also occur if a session was manually expired, but not
+                            // dropped, and the remote party is still sending us data.
+                            return Err(byzantine_fault!(FaultType::ExpiredCounter, true));
+                        }
+                        if packet_type != PACKET_TYPE_DATA {
+                            // This is a control packet.
+                            if fragment_count != 1 || fragment_no > 0 {
+                                return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                            }
+                            return receive_control_fragment(
+                                self,
+                                session,
+                                app,
+                                send_to,
+                                packet_type,
+                                incoming_counter,
+                                incoming_physical_packet_buf.as_mut(),
+                                current_time,
+                            );
+                        }
+                    } else if packet_type == PACKET_TYPE_NOISE_XK_PATTERN_2 {
+                        // We need to reject fragments marked with this type if they are sent out
+                        // of sequence, since an attacker is able to replay them.
+                        match &session.state.read().unwrap().outgoing_offer {
+                            OfferStateMachine::NoiseXKPattern1or3(handshake_state) => match &handshake_state.offer {
+                                NoiseXKAliceHandshakeState::NoiseXKPattern1 { .. } => {
+                                    if incoming_counter >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
+                                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                                    }
+                                }
+                                // This error can occur naturally if Bob's initial reply to Alice had a
+                                // resend that was delayed massively and arrived out of order.
+                                _ => return Err(byzantine_fault!(FaultType::OutOfSequence, true)),
+                            },
+                            _ => return Err(byzantine_fault!(FaultType::OutOfSequence, false)),
+                        };
+                    } else if packet_type == PACKET_TYPE_NOISE_XK_PATTERN_3 {
+                        // This can be triggered if Bob successfully received a session key and
+                        // needs to reject all of Alice's resends of PACKET_TYPE_NOISE_XK_PATTERN_3.
+                        return Err(byzantine_fault!(FaultType::OutOfSequence, true));
+                    } else {
+                        return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                    }
+                    // Handle defragmentation.
+                    let fragments = if fragment_count > 1 {
+                        let idx = incoming_counter as usize % session.defrag.len();
+                        session.defrag[idx].lock().unwrap().assemble(
+                            header_nonce,
+                            incoming_physical_packet_buf,
+                            fragment_no,
+                            fragment_count,
+                            &mut assembled_packet,
+                        );
+                        if assembled_packet.is_empty() {
+                            // We have not yet authenticated the sender so we do not report
+                            // receiving a packet from them.
+                            return Ok(ReceiveResult::Unassociated);
+                        } else {
+                            assembled_packet.as_ref()
+                        }
+                    } else {
+                        std::array::from_ref(&incoming_physical_packet_buf)
+                    };
+                    // Handle DATA in the fastest path when we have a session.
+                    if packet_type == PACKET_TYPE_DATA {
+                        let state = session.state.read().unwrap();
+                        // The error here can occur because the other party is using a brand new
+                        // session key that we have not received yet.
+                        let key = state.cipher_states[key_index]
+                            .as_ref()
+                            .ok_or(byzantine_fault!(FaultType::OutOfSequence, true))?;
+                        let mut c = key.get_receive_cipher(incoming_counter);
+                        c.set_iv(&create_message_nonce(packet_type, incoming_counter));
+
+                        let mut data_len = 0;
+
+                        // Decrypt fragments 0..N-1 where N is the number of fragments.
+                        for f in fragments[..(fragments.len() - 1)].iter() {
+                            let f: &[u8] = f.as_ref();
+                            debug_assert!(f.len() >= HEADER_SIZE);
+                            let current_frag_data_start = data_len;
+                            data_len += f.len() - HEADER_SIZE;
+                            if data_len > data_buf.len() {
+                                return Err(ReceiveError::DataBufferTooSmall);
+                            }
+                            c.decrypt(&f[HEADER_SIZE..], &mut data_buf[current_frag_data_start..data_len]);
+                        }
+
+                        // Decrypt final fragment (or only fragment if not fragmented)
+                        let current_frag_data_start = data_len;
+                        let last_fragment = fragments.last().unwrap().as_ref();
+                        if last_fragment.len() < (HEADER_SIZE + AES_GCM_TAG_SIZE) {
+                            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                        }
+                        data_len += last_fragment.len() - (HEADER_SIZE + AES_GCM_TAG_SIZE);
+                        if data_len > data_buf.len() {
+                            return Err(ReceiveError::DataBufferTooSmall);
+                        }
+                        let payload_end = last_fragment.len() - AES_GCM_TAG_SIZE;
+                        c.decrypt(&last_fragment[HEADER_SIZE..payload_end], &mut data_buf[current_frag_data_start..data_len]);
+
+                        let aead_authentication_ok = c.finish_decrypt(&last_fragment[payload_end..].try_into().unwrap());
+                        drop(c);
+                        drop(state);
+
+                        if !aead_authentication_ok {
+                            return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                        }
+                        if !session.update_receive_window(incoming_counter) {
+                            // This can be naturally triggered because Bob has just
+                            // successfully received a session key and needs to reject
+                            // all of Alice's resends.
+                            // This can also occur naturally if some part of the outer
+                            // system is duplicating the packets being sent to us.
+                            // We are safely deduplicating them here.
+                            return Err(byzantine_fault!(FaultType::ExpiredCounter, true));
+                        }
+                        // Packet fully authenticated
+                        return Ok(ReceiveResult::Session(session, SessionEvent::Data(&mut data_buf[..data_len])));
+                    } else if packet_type == PACKET_TYPE_NOISE_XK_PATTERN_2 {
+                        (Some(session), packet_type, fragments)
+                    } else {
+                        unreachable!()
+                    }
+                } else {
+                    drop(session_map);
+                    // Check for and handle PACKET_TYPE_ALICE_NOISE_XK_PATTERN_3
+                    incoming = self.0.unassociated_handshake_states.get(local_key_id);
+                    if let Some(incoming) = incoming.as_ref() {
+                        Application::PrpDec::new(incoming.header_receive_key.as_ref()).decrypt_in_place(
+                            (&mut incoming_physical_packet[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END])
+                                .try_into()
+                                .unwrap(),
+                        );
+                        let (fragment_count, fragment_no, packet_type, _, header_nonce) = parse_packet_header(incoming_physical_packet);
+                        app.event_log(
+                            LogEvent::ReceiveUnassociatedFragment(fragment_count, fragment_no, packet_type),
+                            current_time,
+                        );
+                        if packet_type != PACKET_TYPE_NOISE_XK_PATTERN_3 {
+                            return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+                        }
+                        let fragments = if fragment_count > 1 {
+                            incoming.noise_pattern3_defrag.lock().unwrap().assemble(
+                                header_nonce,
+                                incoming_physical_packet_buf,
+                                fragment_no,
+                                fragment_count,
+                                &mut assembled_packet,
+                            );
+                            if !assembled_packet.is_empty() {
+                                assembled_packet.as_ref()
+                            } else {
+                                return Ok(ReceiveResult::Unassociated);
+                            }
+                        } else {
+                            std::array::from_ref(&incoming_physical_packet_buf)
+                        };
+                        // We must guarantee that this incoming handshake is processed once and only
+                        // once. This prevents catastrophic nonce reuse caused by multithreading.
+                        if self.0.unassociated_handshake_states.remove(local_key_id) {
+                            (None, PACKET_TYPE_NOISE_XK_PATTERN_3, fragments)
+                        } else {
+                            return Ok(ReceiveResult::Unassociated);
+                        }
+                    } else {
+                        // This can occur naturally because either Bob's incoming_sessions cache got
+                        // full so Alice's incoming session was dropped, or the session this packet
+                        // was for was dropped by the application.
+                        return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
+                    }
+                }
+            } else {
+                let (fragment_count, fragment_no, packet_type, _, header_nonce) = parse_packet_header(incoming_physical_packet);
+                app.event_log(
+                    LogEvent::ReceiveUnassociatedFragment(fragment_count, fragment_no, packet_type),
+                    current_time,
+                );
+                if packet_type != PACKET_TYPE_NOISE_XK_PATTERN_1 && packet_type != PACKET_TYPE_BOB_DOS_CHALLENGE {
+                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+                }
+                let fragments = if fragment_count > 1 {
+                    self.0.unassociated_defrag_cache.lock().unwrap().assemble(
+                        header_nonce,
+                        remote_address,
+                        incoming_physical_packet_len - HEADER_SIZE,
+                        incoming_physical_packet_buf,
+                        fragment_no,
+                        fragment_count,
+                        Application::RETRY_INTERVAL_MS,
+                        current_time,
+                        &mut assembled_packet,
+                    );
+                    if !assembled_packet.is_empty() {
+                        assembled_packet.as_ref()
+                    } else {
+                        return Ok(ReceiveResult::Unassociated);
+                    }
+                } else {
+                    std::array::from_ref(&incoming_physical_packet_buf)
+                };
+                (None, packet_type, fragments)
+            }
+        };
+
+        debug_assert!(!fragments.is_empty());
+        debug_assert!(incoming.is_none() || session.is_none());
+
+        let message = &mut [0u8; MAX_NOISE_HANDSHAKE_SIZE];
+        let message_size = assemble_fragments_into::<Application>(fragments, message)?;
+        if message_size < MIN_PACKET_SIZE {
+            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+        }
+
+        use OfferStateMachine::*;
+        match packet_type {
+            PACKET_TYPE_NOISE_XK_PATTERN_1 => {
+                // Alice (remote) --> Bob (local)
+                // -> e, es, e1
+                app.event_log(LogEvent::ReceiveUncheckedXK1, current_time);
+
+                if session.is_some() || incoming.is_some() {
+                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+                }
+                if !(NoiseXKPattern1::MIN_SIZE..=NoiseXKPattern1::MAX_SIZE).contains(&message_size) {
+                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                }
+                // The message id must be the first 8 bytes of the gcm tag.
+                // This forces the message id to be authenticated along with the entire message.
+                let p_auth_end = message_size - ChallengeResponse::SIZE;
+                if message[8..16] != message[p_auth_end - 8..p_auth_end] {
+                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                }
+                let p_size = p_auth_end - NoiseXKPattern1::P_ENC_START - AES_GCM_TAG_SIZE;
+                let total_ratchet_fingerprints = p_size / RATCHET_SIZE;
+                if p_size % RATCHET_SIZE != 0 || total_ratchet_fingerprints > 2 {
+                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                }
+
+                let noise_pattern1: &NoiseXKPattern1 = byte_array_as_proto_buffer(message);
+                if let Some(remote_key_id) = NonZeroU32::new(u32::from_ne_bytes(noise_pattern1.alice_key_id)) {
+                    let sha512 = &mut Application::Hash::new();
+                    // Let application filter incoming connection attempts by whatever criteria it wants.
+                    // This should ideally prevent ZSSP from wasting time on DDOS attacks.
+                    match check_allow_incoming_session() {
+                        IncomingSessionAction::Allow => {}
+                        IncomingSessionAction::Challenge => {
+                            let response: &ChallengeResponse = byte_array_as_proto_buffer(&message[p_auth_end..message_size]);
+                            let counter = u64::from_be_bytes(response.challenge_counter.try_into().unwrap());
+
+                            sha512.reset();
+                            let mut hasher = ShaHasher(sha512);
+                            let mut output = [0u8; HASHLEN];
+                            hasher.0.update(&response.challenge_counter);
+                            remote_address.hash(&mut hasher);
+                            hasher.0.update(&self.0.challenge_salt);
+                            hasher.0.finish(&mut output);
+                            let is_valid = self.check_challenge_window(counter)
+                                && secure_eq(&output[..CHALLENGE_MAC_SIZE], &response.challenge_mac)
+                                && verify_pow::<Application>(hasher.0, &message[p_auth_end..message_size])
+                                && self.update_challenge_window(counter);
+                            app.event_log(LogEvent::ReceiveCheckXK1Challenge(is_valid), current_time);
+                            if !is_valid {
+                                // Alice failed the challenge so issue them a new challenge.
+                                let mut challenge_buffer = [0u8; BobDOSChallenge::SIZE];
+                                let challenge: &mut BobDOSChallenge = byte_array_as_proto_buffer_mut(&mut challenge_buffer);
+                                challenge.alice_key_id = remote_key_id.get().to_ne_bytes();
+                                // We attach a monotonically increasing counter value to the challenge
+                                // so it cannot be replayed.
+                                let counter = self.0.challenge_counter.fetch_add(1, Ordering::Relaxed);
+                                challenge.challenge_counter = counter.to_be_bytes();
+
+                                hasher.0.reset();
+                                hasher.0.update(&counter.to_be_bytes());
+                                remote_address.hash(&mut hasher);
+                                hasher.0.update(&self.0.challenge_salt);
+                                hasher.0.finish(&mut output);
+                                challenge.challenge_mac.copy_from_slice(&output[..CHALLENGE_MAC_SIZE]);
+                                challenge.prior_challenge_pow = response.challenge_pow;
+                                // We haven't decrypted any of Alice's packet so we don't know the
+                                // header protection cipher.
+                                // For DOS resistance Alice will not accept unencrypted headers directly
+                                // into their session defrag buffer, so we have to send them this reply
+                                // through their incoming sessions cache.
+                                send_with_fragmentation(
+                                    &mut send_unassociated_reply,
+                                    send_unassociated_mtu,
+                                    &mut challenge_buffer,
+                                    PACKET_TYPE_BOB_DOS_CHALLENGE,
+                                    None,
+                                    self.0.rng.lock().unwrap().next_u64(),
+                                    None::<&Application::PrpEnc>,
+                                );
+                                return Ok(ReceiveResult::Unassociated);
+                            }
+                            // Alice succeeded at the challenge so continue to decryption.
+                        }
+                        IncomingSessionAction::Drop => return Ok(ReceiveResult::Rejected),
+                    }
+
+                    // Noise process handshake prologue.
+                    let noise_h = mix_hash(
+                        sha512,
+                        &INITIAL_H,
+                        &message[NoiseXKPattern1::PROLOGUE_START..NoiseXKPattern1::PROLOGUE_END],
+                    );
+                    let noise_h = mix_hash(sha512, &noise_h, self.0.static_keypair.public_key_bytes());
+                    // Noise process pattern1 e token.
+                    let mut noise_ck = SymmetricState::new(INITIAL_H);
+                    let hmac = &mut Application::HmacHash::new();
+                    let mut noise_es = Secret::new();
+                    let noise_e_pattern1 = from_bytes_agreement::<Application>(&noise_pattern1.noise_e, &self.0.static_keypair, noise_es.as_mut())
+                        .ok_or(byzantine_fault!(FaultType::FailedAuthentication, false))?;
+                    let noise_h_e = mix_hash(sha512, &noise_h, &noise_pattern1.noise_e);
+                    noise_ck.mix_key(hmac, &noise_pattern1.noise_e);
+                    // Noise process pattern1 es token.
+                    let noise_k_es = noise_ck.mix_key_initialize_key(hmac, noise_es.as_ref());
+                    drop(noise_es);
+                    // Noise process pattern1 e1 token.
+                    let (is_auth, noise_h_ee1) = decrypt_and_hash::<Application>(
+                        sha512,
+                        &noise_k_es,
+                        &noise_h_e,
+                        packet_type,
+                        0,
+                        &mut message[NoiseXKPattern1::E1_ENC_START..NoiseXKPattern1::P_ENC_START],
+                    );
+                    if !is_auth {
+                        // This could occur naturally if Alice's ApplicationLayer is dynamically
+                        // changing their mtu, which in bad network conditions could clobber their
+                        // resent KEX packet.
+                        // Or maybe Alice randomly generated the same temporary id twice in a row.
+                        // Since these situations are super unlikely to occur we still mark this error
+                        // as unnatural.
+                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                    }
+                    // Noise process pattern1 payload.
+                    let (is_auth, noise_h_ee1p) = decrypt_and_hash::<Application>(
+                        sha512,
+                        &noise_k_es,
+                        &noise_h_ee1,
+                        packet_type,
+                        1,
+                        &mut message[NoiseXKPattern1::P_ENC_START..p_auth_end],
+                    );
+                    drop(noise_k_es);
+                    if !is_auth {
+                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                    }
+                    let (header_b2a_key, header_a2b_key) = noise_ck.get_ask2(hmac, LABEL_HEADER_KEY, &noise_h_ee1p);
+                    // Get ratchet key.
+                    let noise_pattern1: &NoiseXKPattern1 = byte_array_as_proto_buffer(message);
+                    let mut ratchet_state = RatchetState::Null;
+                    for i in 0..total_ratchet_fingerprints {
+                        match app.restore_by_fingerprint(
+                            (&noise_pattern1.payload[i * RATCHET_SIZE..(i + 1) * RATCHET_SIZE]).try_into().unwrap(),
+                            current_time,
+                        ) {
+                            Ok(RatchetState::Null) | Ok(RatchetState::Empty) => {}
+                            Ok(rs) => {
+                                ratchet_state = rs;
+                                break;
+                            }
+                            Err(e) => return Err(ReceiveError::RatchetIoError(e)),
+                        }
+                    }
+                    if ratchet_state.is_null() {
+                        if app.hello_requires_recognized_ratchet(current_time) {
+                            return Ok(ReceiveResult::Rejected);
+                        }
+                        ratchet_state = RatchetState::Empty;
+                    }
+
+                    // Start of Noise XKhfs+psk2 pattern2.
+                    let mut message2 = [0u8; NoiseXKPattern2::SIZE];
+                    let noise_pattern2: &mut NoiseXKPattern2 = byte_array_as_proto_buffer_mut(&mut message2);
+                    // Noise process pattern2 e token.
+                    let noise_e_pattern2_secret = Application::KeyPair::generate(&mut self.0.rng.lock().unwrap());
+                    noise_pattern2.noise_e = *noise_e_pattern2_secret.public_key_bytes();
+                    let noise_h_ee1pe = mix_hash(sha512, &noise_h_ee1p, &noise_pattern2.noise_e);
+                    noise_ck.mix_key(hmac, &noise_pattern2.noise_e);
+                    // Noise process pattern2 ee token.
+                    let mut noise_ee = Secret::new();
+                    if !noise_e_pattern2_secret.agree(&noise_e_pattern1, noise_ee.as_mut()) {
+                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                    }
+                    let noise_k_esee = noise_ck.mix_key_initialize_key(hmac, noise_ee.as_ref());
+                    drop(noise_ee);
+                    // Noise process pattern2 ekem1 token.
+                    let (noise_ekem1, noise_ekem1_secret) = pqc_kyber::encapsulate(&noise_pattern1.noise_e1, self.0.rng.lock().unwrap().deref_mut())
+                        .map_err(|_| byzantine_fault!(FaultType::FailedAuthentication, false))
+                        .map(|(ct, ekem1)| (ct, Secret(ekem1)))?;
+                    // Alice fully authenticated.
+                    noise_pattern2.noise_ekem1 = noise_ekem1;
+                    let noise_h_ee1peekem1 = encrypt_and_hash::<Application>(
+                        sha512,
+                        &noise_k_esee,
+                        &noise_h_ee1pe,
+                        PACKET_TYPE_NOISE_XK_PATTERN_2,
+                        0,
+                        &mut message2[NoiseXKPattern2::EKEM1_ENC_START..NoiseXKPattern2::P_ENC_START],
+                    );
+                    drop(noise_k_esee);
+                    noise_ck.mix_key(hmac, noise_ekem1_secret.as_ref());
+                    drop(noise_ekem1_secret);
+                    // Noise process pattern2 psk token.
+                    let ratchet_key = ratchet_state.key().unwrap();
+                    let (temp_h, noise_k_eseeekem1psk) = noise_ck.mix_key_and_hash_initialize_key(hmac, ratchet_key);
+                    let noise_h_ee1peekem1psk = mix_hash(sha512, &noise_h_ee1peekem1, &temp_h);
+                    // Noise process pattern2 payload.
+                    // We try to prevent the id we generate from colliding with another session but
+                    // because we might have handshakes in flight it's impossible to 100% prevent.
+                    // In those exceedingly rare cases we have to drop Alice's session and start over.
+                    let local_key_id = generate_key_id(&self.0.session_map.read().unwrap(), &mut self.0.rng.lock().unwrap());
+                    let noise_pattern2: &mut NoiseXKPattern2 = byte_array_as_proto_buffer_mut(&mut message2);
+                    noise_pattern2.bob_key_id = local_key_id.get().to_ne_bytes();
+
+                    let noise_h_ee1peekem1pskp = encrypt_and_hash::<Application>(
+                        sha512,
+                        &noise_k_eseeekem1psk,
+                        &noise_h_ee1peekem1psk,
+                        PACKET_TYPE_NOISE_XK_PATTERN_2,
+                        0,
+                        &mut message2[NoiseXKPattern2::P_ENC_START..NoiseXKPattern2::P_AUTH_END],
+                    );
+
+                    app.event_log(LogEvent::ReceiveValidXK1, current_time);
+                    let handshake = Arc::new(NoiseXKBobHandshakeState {
+                        local_key_id,
+                        remote_key_id,
+                        ratchet_state,
+                        noise_h_ee1peekem1pskp,
+                        noise_ck_eseeekem1psk: noise_ck.clone(),
+                        noise_k_eseeekem1psk: noise_k_eseeekem1psk.clone(),
+                        noise_e_secret: noise_e_pattern2_secret,
+                        header_receive_key: header_a2b_key.clone(),
+                        header_send_key: header_b2a_key.clone(),
+                        noise_pattern3_defrag: Mutex::new(Fragged::new()),
+                    });
+                    self.0.unassociated_handshake_states.insert(local_key_id, handshake, current_time);
+
+                    // We put a copy of the gcm tag in the header so Alice can tell this packet apart
+                    // from any other pattern 1 packet we send, without having to make Bob maintain state.
+                    let mut pattern2_id = 0u64.to_ne_bytes();
+                    pattern2_id[5] = message2[NoiseXKPattern2::P_AUTH_END - 3];
+                    pattern2_id[6] = message2[NoiseXKPattern2::P_AUTH_END - 2];
+                    pattern2_id[7] = message2[NoiseXKPattern2::P_AUTH_END - 1];
+                    send_with_fragmentation(
+                        &mut send_unassociated_reply,
+                        send_unassociated_mtu,
+                        &mut message2,
+                        PACKET_TYPE_NOISE_XK_PATTERN_2,
+                        Some(remote_key_id),
+                        u64::from_be_bytes(pattern2_id),
+                        Some(&Application::PrpEnc::new(header_b2a_key.first_n::<AES_GCM_KEY_SIZE>())),
+                    );
+
+                    return Ok(ReceiveResult::Unassociated);
+                } else {
+                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                }
+            }
+            PACKET_TYPE_BOB_DOS_CHALLENGE => {
+                let message = &mut message[..message_size];
+                app.event_log(LogEvent::ReceiveUncheckedDOSChallenge, current_time);
+
+                // We expect Bob to only send this to us through our unassociated defrag cache.
+                if incoming.is_some() || session.is_some() {
+                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+                }
+                if message.len() != BobDOSChallenge::SIZE {
+                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                }
+                let challenge: &BobDOSChallenge = byte_array_as_proto_buffer(message);
+
+                if let Some(local_key_id) = NonZeroU32::new(u32::from_ne_bytes(challenge.alice_key_id)) {
+                    if let Some(session) = self.0.session_map.read().unwrap().get(&local_key_id).and_then(|s| s.0.upgrade()) {
+                        // We don't need to hold the kex lock because we are not transitioning state.
+                        let mut state = session.state.write().unwrap();
+                        if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
+                            if let NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, .. } = &mut handshake_state.offer {
+                                let response_raw = &mut noise_message[*noise_message_len - ChallengeResponse::SIZE..];
+
+                                let response: &mut ChallengeResponse = byte_array_as_proto_buffer_mut(response_raw);
+                                // Only people who know what Alice's prior pow was can convince us to
+                                // compute a new pow.
+                                if challenge.prior_challenge_pow != response.challenge_pow {
+                                    // This can occur if Bob sends us multiple challenges and they
+                                    // arrive OOO.
+                                    return Err(byzantine_fault!(FaultType::FailedAuthentication, true));
+                                }
+                                response.challenge_counter.copy_from_slice(&challenge.challenge_counter);
+                                response.challenge_mac.copy_from_slice(&challenge.challenge_mac);
+                                let mut pow = self.0.rng.lock().unwrap().next_u64();
+                                let sha512 = &mut Application::Hash::new();
+                                loop {
+                                    let response: &mut ChallengeResponse = byte_array_as_proto_buffer_mut(response_raw);
+                                    response.challenge_pow.copy_from_slice(&pow.to_be_bytes());
+                                    if verify_pow::<Application>(sha512, response_raw) {
+                                        break;
+                                    }
+                                    pow = pow.wrapping_add(1);
+                                }
+
+                                app.event_log(LogEvent::ReceiveValidDOSChallenge(&session), current_time);
+                                return Ok(ReceiveResult::Unassociated);
+                            } else {
+                                // This could happen if Bob challenges Alice, but their challenge packet
+                                // gets massively delayed.
+                                return Err(byzantine_fault!(FaultType::OutOfSequence, true));
+                            }
+                        } else {
+                            // This could happen if Bob challenges Alice, but their challenge packet
+                            // gets massively delayed.
+                            return Err(byzantine_fault!(FaultType::OutOfSequence, true));
+                        }
+                    } else {
+                        // This can occur naturally if Alice's session was dropped.
+                        return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
+                    }
+                } else {
+                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                }
+            }
+            PACKET_TYPE_NOISE_XK_PATTERN_2 => {
+                // Bob (remote) --> Alice (local)
+                // <- e, ee, ekem1, psk
+                let message = &mut message[..message_size];
+                app.event_log(LogEvent::ReceiveUncheckedXK2, current_time);
+
+                if incoming.is_some() {
+                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+                }
+                if message.len() != NoiseXKPattern2::SIZE {
+                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                }
+
+                let session = session.ok_or(byzantine_fault!(FaultType::UnknownLocalKeyId, false))?;
+                let kex_lock = session.state_machine_lock.lock().unwrap();
+                let state = session.state.read().unwrap();
+
+                if let NoiseXKPattern1or3(handshake_state) = &state.outgoing_offer {
+                    if let NoiseXKAliceHandshakeState::NoiseXKPattern1 {
+                        noise_h_ee1p, noise_e_secret, noise_e1_secret, noise_ck_es, ..
+                    } = &handshake_state.offer
+                    {
+                        let noise_pattern2: &NoiseXKPattern2 = byte_array_as_proto_buffer(message);
+                        // Authenticate header counter.
+                        if noise_pattern2.header[13..16] != noise_pattern2.p_gcm_tag[13..16] {
+                            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                        }
+
+                        // Noise process pattern2 e token.
+                        let mut noise_ee = Secret::new();
+                        if let Some(noise_e_pattern2) =
+                            from_bytes_agreement::<Application>(&noise_pattern2.noise_e, noise_e_secret, noise_ee.as_mut())
+                        {
+                            let sha512 = &mut Application::Hash::new();
+                            let hmac = &mut Application::HmacHash::new();
+                            let mut noise_ck = noise_ck_es.clone();
+                            let noise_h_ee1pe = mix_hash(sha512, noise_h_ee1p, noise_e_pattern2.as_bytes());
+                            noise_ck.mix_key(hmac, noise_e_pattern2.as_bytes());
+                            // Noise process pattern2 ee token.
+                            let noise_k_esee = noise_ck.mix_key_initialize_key(hmac, noise_ee.as_ref());
+                            drop(noise_ee);
+                            // Noise process pattern2 ekem1 token.
+                            let (is_auth, noise_h_ee1peekem1) = decrypt_and_hash::<Application>(
+                                sha512,
+                                &noise_k_esee,
+                                &noise_h_ee1pe,
+                                packet_type,
+                                0,
+                                &mut message[NoiseXKPattern2::EKEM1_ENC_START..NoiseXKPattern2::P_ENC_START],
+                            );
+                            let noise_pattern2: &NoiseXKPattern2 = byte_array_as_proto_buffer(message);
+                            let noise_ekem1_secret = pqc_kyber::decapsulate(&noise_pattern2.noise_ekem1, noise_e1_secret.as_ref()).map(Secret);
+                            if let Some(Ok(noise_ekem1_secret)) = is_auth.then_some(noise_ekem1_secret) {
+                                noise_ck.mix_key(hmac, noise_ekem1_secret.as_ref());
+                                drop(noise_ekem1_secret);
+
+                                // We attempt to decrypt the payload at most three times. First two times with
+                                // the ratchet key Alice remembers, and final time with a ratchet
+                                // key of zero if Alice allows ratchet downgrades.
+                                // The following code is not constant time, meaning we leak to an
+                                // attacker whether or not we downgraded.
+                                // We don't currently consider this sensitive enough information to hide.
+                                let mut test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState, Secret<AES_GCM_KEY_SIZE>, [u8; 64])> {
+                                    // Check for which ratchet key Bob wants to use.
+                                    let mut noise_ck = noise_ck.clone();
+                                    let mut payload = [0u8; NoiseXKPattern2::P_AUTH_END - NoiseXKPattern2::P_ENC_START];
+                                    payload.copy_from_slice(&message[NoiseXKPattern2::P_ENC_START..NoiseXKPattern2::P_AUTH_END]);
+                                    // Noise process pattern2 psk token.
+                                    let (temp_h, noise_k_eseeekem1psk) = noise_ck.mix_key_and_hash_initialize_key(hmac, ratchet_key);
+                                    let noise_h_ee1peekem1psk = mix_hash(sha512, &noise_h_ee1peekem1, &temp_h);
+                                    // Noise process pattern2 payload.
+                                    let (is_auth, noise_h_ee1peekem1pskp) = decrypt_and_hash::<Application>(
+                                        sha512,
+                                        &noise_k_eseeekem1psk,
+                                        &noise_h_ee1peekem1psk,
+                                        packet_type,
+                                        0,
+                                        &mut payload,
+                                    );
+                                    if is_auth {
+                                        let key_id = NonZeroU32::new(u32::from_ne_bytes(
+                                            (&payload[..NoiseXKPattern2::P_AUTH_START - NoiseXKPattern2::P_ENC_START])
+                                                .try_into()
+                                                .unwrap(),
+                                        ));
+                                        key_id.map(|kid| (kid, noise_ck, noise_k_eseeekem1psk, noise_h_ee1peekem1pskp))
+                                    } else {
+                                        None
+                                    }
+                                };
+                                // Check first key.
+                                let mut ratchet_i = 0;
+                                let mut result = None;
+                                let mut chain_len = 0;
+                                if let Some(key) = state.ratchet_states[0].key() {
+                                    chain_len = state.ratchet_states[0].chain_len();
+                                    result = test_ratchet_key(key);
+                                }
+                                // Check second key.
+                                if result.is_none() {
+                                    ratchet_i = 1;
+                                    if let Some(key) = state.ratchet_states[1].key() {
+                                        chain_len = state.ratchet_states[1].chain_len();
+                                        result = test_ratchet_key(key);
+                                    }
+                                }
+                                // Check zero key.
+                                if result.is_none() && !app.initiator_disallows_downgrade(&session, current_time) {
+                                    chain_len = 0;
+                                    result = test_ratchet_key(&[0u8; RATCHET_SIZE]);
+                                    if result.is_some() {
+                                        // TODO: add some kind of warning callback or signal.
+                                    }
+                                }
+
+                                if let Some((remote_key_id, mut noise_ck, noise_k_eseeekem1psk, noise_h_ee1peekem1pskp)) = result {
+                                    // Start of Noise XKhfs+psk2 pattern3.
+                                    let mut message3 = [0u8; NoiseXKPattern3::MAX_SIZE];
+                                    // Noise process pattern3 s token.
+                                    let mut noise_se = Secret::new();
+                                    if self.0.static_keypair.agree(&noise_e_pattern2, noise_se.as_mut()) {
+                                        let payload = handshake_state.alice_identity_blob.as_ref();
+                                        // Packet fully authenticated.
+                                        let s_enc_start = HEADER_SIZE;
+                                        let s_auth_start = s_enc_start + P384_PUBLIC_KEY_SIZE;
+                                        let p_enc_start = s_auth_start + AES_GCM_TAG_SIZE;
+                                        let p_auth_start = p_enc_start + payload.len();
+                                        let p_auth_end = p_auth_start + AES_GCM_TAG_SIZE;
+                                        let message3_len = p_auth_end;
+
+                                        message3[s_enc_start..s_auth_start].copy_from_slice(self.0.static_keypair.public_key_bytes());
+                                        let noise_h_ee1peekem1pskps = encrypt_and_hash::<Application>(
+                                            sha512,
+                                            &noise_k_eseeekem1psk,
+                                            &noise_h_ee1peekem1pskp,
+                                            PACKET_TYPE_NOISE_XK_PATTERN_3,
+                                            1,
+                                            &mut message3[s_enc_start..p_enc_start],
+                                        );
+                                        drop(noise_k_eseeekem1psk);
+                                        // Noise process pattern3 se token.
+                                        let noise_k_eseeekem1pskse = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
+                                        drop(noise_se);
+                                        // Noise process pattern3 payload token.
+                                        message3[p_enc_start..p_auth_start].copy_from_slice(payload);
+                                        let noise_h_ee1peekem1pskpsp = encrypt_and_hash::<Application>(
+                                            sha512,
+                                            &noise_k_eseeekem1pskse,
+                                            &noise_h_ee1peekem1pskps,
+                                            PACKET_TYPE_NOISE_XK_PATTERN_3,
+                                            0,
+                                            &mut message3[p_enc_start..p_auth_end],
+                                        );
+                                        drop(noise_k_eseeekem1pskse);
+                                        // Alice finished Noise XKhfs+psk2 handshake.
+                                        // Transition offer state machine to the NoiseXKPattern3 state.
+                                        let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_ee1peekem1pskpsp);
+                                        let new_ratchet_state = RatchetState::new_nonempty(rk, rf, NonZeroU64::new(chain_len + 1).unwrap());
+
+                                        let ratchet_to_preserve = &state.ratchet_states[ratchet_i];
+                                        let result = app.save_ratchet_state(
+                                            &session.remote_static_key,
+                                            &session.application_data,
+                                            [&state.ratchet_states[0], &state.ratchet_states[1]],
+                                            [&new_ratchet_state, ratchet_to_preserve],
+                                            current_time,
+                                        );
+                                        if let Err(e) = result {
+                                            return Err(ReceiveError::RatchetIoError(e));
+                                        }
+
+                                        let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_ee1peekem1pskpsp);
+
+                                        let local_key_id = handshake_state.local_key_id;
+                                        drop(state);
+                                        let mut state = session.state.write().unwrap();
+                                        session
+                                            .kex_send_cipher
+                                            .lock()
+                                            .unwrap()
+                                            .replace(Application::AeadEnc::new(kex_key_a2b.as_ref()));
+                                        session
+                                            .kex_receive_cipher
+                                            .lock()
+                                            .unwrap()
+                                            .replace(Application::AeadDec::new(kex_key_b2a.as_ref()));
+                                        state.ratchet_states[1] = state.ratchet_states[ratchet_i].clone();
+                                        state.ratchet_states[0] = new_ratchet_state;
+
+                                        state.cipher_states[0].replace(SessionKey::new(
+                                            hmac,
+                                            noise_ck,
+                                            local_key_id,
+                                            remote_key_id,
+                                            INIT_COUNTER,
+                                            false,
+                                        ));
+                                        debug_assert!(state.cipher_states[1].is_none());
+                                        if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
+                                            handshake_state.next_retry_time =
+                                                AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS));
+                                            handshake_state.timeout = current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS);
+                                            handshake_state.offer = NoiseXKAliceHandshakeState::NoiseXKPattern3 {
+                                                noise_message: message3,
+                                                noise_message_len: p_auth_end,
+                                            };
+                                        }
+                                        drop(state);
+                                        drop(kex_lock);
+
+                                        if let Some((mut send, mut mtu)) = send_to(&session) {
+                                            mtu = mtu.max(MIN_TRANSPORT_MTU);
+                                            send_with_fragmentation(
+                                                &mut send,
+                                                mtu,
+                                                &mut message3[..message3_len],
+                                                PACKET_TYPE_NOISE_XK_PATTERN_3,
+                                                Some(remote_key_id),
+                                                0,
+                                                Some(&session.header_send_cipher),
+                                            );
+                                        }
+                                        app.event_log(LogEvent::ReceiveValidXK2(&session), current_time);
+                                        return Ok(ReceiveResult::Session(session, SessionEvent::Control));
+                                    }
+                                }
+                            }
+                        }
+                        // Bob failed authentication so we must restart our offer according to Noise.
+                        // We restart the offer instead of dropping the session to defend against DOS.
+                        drop(state);
+                        let mut state = session.state.write().unwrap();
+                        let ratchet_state = state.ratchet_states.clone();
+                        if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
+                            if !handshake_state.reinitialize(
+                                &session,
+                                &ratchet_state,
+                                &mut self.0.session_map.write().unwrap(),
+                                &mut self.0.rng.lock().unwrap(),
+                                current_time,
+                            ) {
+                                session.expire()
+                            }
+                        }
+                        drop(state);
+                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                    } else {
+                        return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+                    }
+                } else {
+                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+                }
+            }
+            PACKET_TYPE_NOISE_XK_PATTERN_3 => {
+                // Alice (remote) --> Bob (local)
+                // -> s, se
+                let message = &mut message[..message_size];
+                app.event_log(LogEvent::ReceiveUncheckedXK3, current_time);
+
+                if session.is_some() {
+                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+                }
+                if message.len() < NoiseXKPattern3::MIN_SIZE || message.len() > NoiseXKPattern3::MAX_SIZE {
+                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                }
+                // The code above guarantees to us that each `incoming` handshake state that reaches
+                // this point will be strictly unique, even for the same remote peer.
+                // This property is strictly necessary to prevent catastrophic nonce reuse due to
+                // two session being created with the same set of keys.
+                let handshake_state = incoming.ok_or(byzantine_fault!(FaultType::UnknownLocalKeyId, false))?;
+                let s_enc_start = HEADER_SIZE;
+
+                let s_auth_start = s_enc_start + P384_PUBLIC_KEY_SIZE;
+                let p_enc_start = s_auth_start + AES_GCM_TAG_SIZE;
+                let p_auth_end = message.len();
+                let p_auth_start = p_auth_end - AES_GCM_TAG_SIZE;
+
+                if !(p_enc_start <= p_auth_start) {
+                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                }
+                // Do not read from the message before this point, otherwise an array out of bounds
+                // error is possible.
+                // Noise process pattern3 s token.
+                let sha512 = &mut Application::Hash::new();
+                let hmac = &mut Application::HmacHash::new();
+                let (is_auth, noise_h_ee1peekem1pskps) = decrypt_and_hash::<Application>(
+                    sha512,
+                    &handshake_state.noise_k_eseeekem1psk,
+                    &handshake_state.noise_h_ee1peekem1pskp,
+                    packet_type,
+                    1,
+                    &mut message[s_enc_start..p_enc_start],
+                );
+                if !is_auth {
+                    return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                }
+                // Noise process pattern3 se token.
+                let mut noise_se = Secret::new();
+                if let Some(remote_s_public_key) =
+                    from_bytes_agreement::<Application>(&message[s_enc_start..s_auth_start], &handshake_state.noise_e_secret, noise_se.as_mut())
+                {
+                    let mut noise_ck = handshake_state.noise_ck_eseeekem1psk.clone();
+                    let noise_k_eseeekem1pskse = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
+                    drop(noise_se);
+                    // Noise process pattern3 payload.
+                    let (is_auth, noise_h_ee1peekem1pskpsp) = decrypt_and_hash::<Application>(
+                        sha512,
+                        &noise_k_eseeekem1pskse,
+                        &noise_h_ee1peekem1pskps,
+                        packet_type,
+                        0,
+                        &mut message[p_enc_start..p_auth_end],
+                    );
+                    drop(noise_k_eseeekem1pskse);
+                    if !is_auth {
+                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                    }
+                    // Bob finished Noise XKhfs+psk2 handshake.
+                    let header_send_cipher = Application::PrpEnc::new(handshake_state.header_send_key.as_ref());
+                    let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_ee1peekem1pskpsp);
+                    let mut send_reject = || {
+                        // We just used a counter with this key, but we are not storing
+                        // the fact we used it in memory. This is currently ok because the
+                        // handshake is being dropped, so nonce reuse can't happen.
+                        let (mut fragment, len) = encrypt_control(
+                            &mut Application::AeadEnc::new(kex_key_b2a.as_ref()),
+                            &header_send_cipher,
+                            PACKET_TYPE_SESSION_REJECTED,
+                            INIT_COUNTER,
+                            handshake_state.remote_key_id.get(),
+                            &[],
+                        );
+                        send_unassociated_reply(&mut fragment[..len]);
+                    };
+
+                    let (responder_disallows_downgrade, responder_silently_rejects) = check_accept_session(
+                        &remote_s_public_key,
+                        &message[p_enc_start..p_auth_start],
+                        handshake_state.ratchet_state.chain_len(),
+                    );
+                    if let Some((responder_disallows_downgrade, application_data)) = responder_disallows_downgrade {
+                        let result = app.restore_by_identity(&remote_s_public_key, &application_data, current_time);
+                        match result {
+                            Ok(true_ratchet_states) => {
+                                let mut has_match = false;
+                                for rs in &true_ratchet_states {
+                                    if !rs.is_null() {
+                                        has_match |= &handshake_state.ratchet_state == rs;
+                                    }
+                                }
+                                if !has_match {
+                                    if !responder_disallows_downgrade && handshake_state.ratchet_state.is_empty() {
+                                        // TODO: add some kind of warning callback or signal.
+                                    } else {
+                                        if !responder_silently_rejects {
+                                            send_reject();
+                                        }
+                                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                                    }
+                                }
+
+                                let mut noise_kk_ss = Secret::new();
+                                if !self.0.static_keypair.agree(&remote_s_public_key, noise_kk_ss.as_mut()) {
+                                    return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                                }
+                                let noise_kk_local_init_h = mix_hash(sha512, &INITIAL_H_REKEY, self.0.static_keypair.public_key_bytes());
+                                let noise_kk_local_init_h = mix_hash(sha512, &noise_kk_local_init_h, remote_s_public_key.as_bytes());
+                                let noise_kk_remote_init_h = mix_hash(sha512, &INITIAL_H_REKEY, remote_s_public_key.as_bytes());
+                                let noise_kk_remote_init_h = mix_hash(sha512, &noise_kk_remote_init_h, self.0.static_keypair.public_key_bytes());
+
+                                let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_ee1peekem1pskpsp);
+                                // We must make sure the ratchet key is saved before we transition.
+                                let new_ratchet_state =
+                                    RatchetState::new_nonempty(rk, rf, NonZeroU64::new(handshake_state.ratchet_state.chain_len() + 1).unwrap());
+                                let result = app.save_ratchet_state(
+                                    &remote_s_public_key,
+                                    &application_data,
+                                    [&true_ratchet_states[0], &true_ratchet_states[1]],
+                                    [&new_ratchet_state, &RatchetState::Null],
+                                    current_time,
+                                );
+                                if let Err(e) = result {
+                                    return Err(ReceiveError::RatchetIoError(e));
+                                }
+
+                                let mut session_queue = self.0.session_queue.lock().unwrap();
+                                let queue_idx = session_queue.reserve_index();
+                                let session = Arc::new(Session {
+                                    context: Arc::downgrade(&self.0),
+                                    queue_idx,
+                                    application_data,
+                                    remote_static_key: remote_s_public_key,
+                                    send_counter: AtomicU64::new(INIT_COUNTER),
+                                    session_has_expired: AtomicBool::new(false),
+                                    counter_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
+                                    state_machine_lock: Mutex::new(()),
+                                    state: RwLock::new(SessionMutableState {
+                                        ratchet_states: [new_ratchet_state.clone(), RatchetState::Null],
+                                        cipher_states: [
+                                            Some(SessionKey::new(
+                                                hmac,
+                                                noise_ck,
+                                                handshake_state.local_key_id,
+                                                handshake_state.remote_key_id,
+                                                INIT_COUNTER,
+                                                true,
+                                            )),
+                                            None,
+                                        ],
+                                        current_key: 0,
+                                        outgoing_offer: KeyConfirm {
+                                            next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
+                                            timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
+                                        },
+                                    }),
+                                    header_receive_cipher: Application::PrpDec::new(handshake_state.header_receive_key.as_ref()),
+                                    header_send_cipher,
+                                    kex_send_cipher: Mutex::new(Some(Application::AeadEnc::new(kex_key_b2a.as_ref()))),
+                                    kex_receive_cipher: Mutex::new(Some(Application::AeadDec::new(kex_key_a2b.as_ref()))),
+                                    noise_kk_ss,
+                                    noise_kk_local_init_h,
+                                    noise_kk_remote_init_h,
+                                    defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
+                                    was_bob: true,
+                                });
+                                let timer = Reverse(current_time.saturating_add(Application::RETRY_INTERVAL_MS));
+                                session_queue.push_reserved(queue_idx, Arc::downgrade(&session), timer);
+                                drop(session_queue);
+                                // There is the miniscule possibility this key id is already
+                                // in use, in which case we have to drop this session like
+                                // nothing ever happened.
+                                let mut session_map = self.0.session_map.write().unwrap();
+                                if let std::collections::hash_map::Entry::Vacant(e) = session_map.entry(handshake_state.local_key_id) {
+                                    e.insert((Arc::downgrade(&session), false));
+                                    drop(session_map);
+                                    let _ =
+                                        session.send_control(&session.state.read().unwrap(), send_unassociated_reply, PACKET_TYPE_KEY_CONFIRM, &[]);
+
+                                    app.event_log(LogEvent::ReceiveValidXK3(&session.application_data), current_time);
+                                    return Ok(ReceiveResult::Session(session, SessionEvent::NewSession));
+                                } else {
+                                    // This can occur if we accidentally generate a key id collision.
+                                    // There is an extremely short amount of time during which
+                                    // another session can steal this session's id, we'll have to
+                                    // restart the handshake in this case.
+                                    return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
+                                }
+                            }
+                            Err(e) => {
+                                return Err(ReceiveError::RatchetIoError(e));
+                            }
+                        }
+                    } else {
+                        if !responder_silently_rejects {
+                            send_reject();
+                        }
+                        return Ok(ReceiveResult::Rejected);
+                    }
+                } else {
+                    return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                }
+            }
+            _ => return Err(byzantine_fault!(FaultType::InvalidPacket, false)),
+        }
+    }
+    /// Helper function for sending the empty string over the session. Useful for keep-alives.
+    ///
+    /// * `session` - The session to send to
+    /// * `send` - Function to call to send physical packet(s); the buffer passed to `send` is a
+    ///   slice of `data`
+    /// * `current_time` - Current time in milliseconds
+    pub fn send_empty(&self, session: &Arc<Session<Application>>, send: impl FnMut(&mut [u8]) -> bool, current_time: i64) -> Result<(), SendError> {
+        self.send(session, send, &mut [0u8; MIN_TRANSPORT_MTU], &[], current_time)
+    }
+    /// Send data over the session.
+    ///
+    /// * `session` - The session to send to
+    /// * `send` - Function to call to send physical packet(s); the buffer passed to `send` is a
+    ///   slice of `data`
+    /// * `mtu_sized_buffer` - A writable work buffer whose size equals the MTU
+    /// * `data` - Data to send
+    /// * `current_time` - Current time in milliseconds
+    pub fn send(
+        &self,
+        session: &Arc<Session<Application>>,
+        mut send: impl FnMut(&mut [u8]) -> bool,
+        mtu_sized_buffer: &mut [u8],
+        mut data: &[u8],
+        current_time: i64,
+    ) -> Result<(), SendError> {
+        if mtu_sized_buffer.len() < MIN_TRANSPORT_MTU {
+            return Err(SendError::InvalidParameter);
+        }
+        let state = session.state.read().unwrap();
+        let key = state.cipher_states[state.current_key].as_ref().ok_or(SendError::SessionNotEstablished)?;
+        let counter = session.get_next_outgoing_counter()?;
+
+        let mut c = key.get_send_cipher(counter)?;
+        c.set_iv(&create_message_nonce(PACKET_TYPE_DATA, counter));
+
+        let fragment_max_chunk_size = mtu_sized_buffer.len() - HEADER_SIZE;
+        let fragment_count = (data.len() + AES_GCM_TAG_SIZE + (fragment_max_chunk_size - 1)) / fragment_max_chunk_size;
+        if fragment_count > MAX_FRAGMENTS {
+            return Err(SendError::DataTooLarge);
+        }
+        let last_fragment_no = fragment_count - 1;
+
+        for fragment_no in 0..fragment_count {
+            let chunk_size = fragment_max_chunk_size.min(data.len());
+            let mut fragment_size = chunk_size + HEADER_SIZE;
+
+            set_packet_header(
+                mtu_sized_buffer,
+                fragment_count as u8,
+                fragment_no as u8,
+                PACKET_TYPE_DATA,
+                key.remote_key_id.get(),
+                counter,
+            );
+
+            c.encrypt(&data[..chunk_size], &mut mtu_sized_buffer[HEADER_SIZE..fragment_size]);
+            data = &data[chunk_size..];
+
+            if fragment_no == last_fragment_no {
+                debug_assert!(data.is_empty());
+                let tagged_fragment_size = fragment_size + AES_GCM_TAG_SIZE;
+                c.finish_encrypt((&mut mtu_sized_buffer[fragment_size..tagged_fragment_size]).try_into().unwrap());
+                fragment_size = tagged_fragment_size;
+            }
+
+            session.header_send_cipher.encrypt_in_place(
+                (&mut mtu_sized_buffer[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END])
+                    .try_into()
+                    .unwrap(),
+            );
+            if !send(&mut mtu_sized_buffer[..fragment_size]) {
+                break;
+            }
+        }
+        drop(c);
+        if counter >= key.rekey_at_counter {
+            if let OfferStateMachine::Normal { .. } = &state.outgoing_offer {
+                drop(state);
+                if let Ok(timer) = initiate_rekey(&self.0, session, send, current_time) {
+                    self.0.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timer));
+                }
+            }
+        }
+        Ok(())
+    }
+    /// Update the challenge window, returning true if the challenge is still valid.
+    fn check_challenge_window(&self, counter: u64) -> bool {
+        let slot = &self.0.challenge_antireplay_window[(counter as usize) % self.0.challenge_antireplay_window.len()];
+        let counter = counter.wrapping_add(1);
+        let prev_counter = slot.load(Ordering::Relaxed);
+        prev_counter < counter
+    }
+    /// Update the challenge window, returning true if the challenge is still valid.
+    fn update_challenge_window(&self, counter: u64) -> bool {
+        let slot = &self.0.challenge_antireplay_window[(counter as usize) % self.0.challenge_antireplay_window.len()];
+        let counter = counter.wrapping_add(1);
+        let prev_counter = slot.fetch_max(counter, Ordering::Relaxed);
+        prev_counter < counter
+    }
+}
+/// Initiate the rekeying protocol. This session will now begin attempting to rekey this session
+/// with its peer, if it was not already.
+fn initiate_rekey<Application: ApplicationLayer>(
+    context: &Arc<ContextInner<Application>>,
+    session: &Arc<Session<Application>>,
+    send: impl FnOnce(&mut [u8]) -> bool,
+    current_time: i64,
+) -> Result<i64, ()> {
+    let mut message = [0u8; NoiseKKPattern1or2::SIZE];
+
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let state = session.state.read().unwrap();
+    // We may only attempt to rekey if we are not already doing so.
+    match &state.outgoing_offer {
+        OfferStateMachine::Normal { .. } => (),
+        _ => return Err(()),
+    }
+    let sha512 = &mut Application::Hash::new();
+    let hmac = &mut Application::HmacHash::new();
+    // Start of Noise KKpsk0 pattern1.
+    // Noise process pattern1 psk0 token.
+    let mut noise_ck = SymmetricState::new(INITIAL_H_REKEY);
+    let noise_temp_h = noise_ck.mix_key_and_hash(hmac, state.ratchet_states[0].key().unwrap());
+    let noise_h_psk = mix_hash(sha512, &session.noise_kk_local_init_h, &noise_temp_h);
+    // Noise process pattern1 e token.
+    let noise_e_secret = Application::KeyPair::generate(&mut context.rng.lock().unwrap());
+    let noise_h_pske = mix_hash(sha512, &noise_h_psk, noise_e_secret.public_key_bytes());
+    noise_ck.mix_key(hmac, noise_e_secret.public_key_bytes());
+
+    let noise_pattern1: &mut NoiseKKPattern1or2 = byte_array_as_proto_buffer_mut(&mut message);
+    noise_pattern1.noise_e = *noise_e_secret.public_key_bytes();
+    // Noise process pattern1 es token.
+    let mut noise_es = Secret::new();
+    if !noise_e_secret.agree(&session.remote_static_key, noise_es.as_mut()) {
+        return Err(());
+    }
+    noise_ck.mix_key(hmac, noise_es.as_ref());
+    drop(noise_es);
+    // Noise process pattern1 ss token.
+    let noise_k_pskesss = noise_ck.mix_key_initialize_key(hmac, session.noise_kk_ss.as_ref());
+    // Noise process pattern1 payload token.
+    let mut session_map = context.session_map.write().unwrap();
+    let new_key_id = generate_key_id(&session_map, &mut context.rng.lock().unwrap());
+    let next_key_index = state.current_key ^ 1;
+    session_map.insert(new_key_id, (Arc::downgrade(session), next_key_index > 0));
+    drop(session_map);
+
+    let noise_pattern1: &mut NoiseKKPattern1or2 = byte_array_as_proto_buffer_mut(&mut message);
+    noise_pattern1.key_id = new_key_id.get().to_ne_bytes();
+    let noise_h_pskep = encrypt_and_hash::<Application>(
+        sha512,
+        &noise_k_pskesss,
+        &noise_h_pske,
+        PACKET_TYPE_NOISE_KK_PATTERN_1,
+        0,
+        &mut message[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
+    );
+    drop(noise_k_pskesss);
+
+    drop(state);
+    let mut state = session.state.write().unwrap();
+    state.outgoing_offer = OfferStateMachine::NoiseKKPattern1 {
+        next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
+        timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
+        new_key_id,
+        noise_e_secret,
+        noise_message: message.clone(),
+        noise_h_pskep,
+        noise_ck: noise_ck.clone(),
+    };
+    drop(state);
+    drop(kex_lock);
+    let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_NOISE_KK_PATTERN_1, &message);
+    Ok(current_time.saturating_add(Application::RETRY_INTERVAL_MS))
+}
+fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mut [u8]) -> bool>(
+    context: &Context<Application>,
+    session: Arc<Session<Application>>,
+    app: &Application,
+    mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
+    packet_type: u8,
+    counter: u64,
+    fragment: &mut [u8],
+    current_time: i64,
+) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::StorageError>> {
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let state = session.state.read().unwrap();
+    let mut c = session.kex_receive_cipher.lock().unwrap();
+    let message = decrypt_control(
+        c.as_mut().ok_or(byzantine_fault!(FaultType::OutOfSequence, false))?,
+        packet_type,
+        counter,
+        fragment,
+    )?;
+    drop(c);
+    session.update_receive_window(counter);
+    use OfferStateMachine::*;
+    return match packet_type {
+        PACKET_TYPE_SESSION_REJECTED => {
+            if let NoiseXKPattern1or3(_) = &state.outgoing_offer {
+                drop(state);
+                let mut state = session.state.write().unwrap();
+                state.outgoing_offer = OfferStateMachine::Null;
+                drop(state);
+                drop(kex_lock);
+                Ok(ReceiveResult::Session(session, SessionEvent::Rejected))
+            } else {
+                // This can occur naturally because of control packet resends.
+                Err(byzantine_fault!(FaultType::OutOfSequence, true))
+            }
+        }
+        PACKET_TYPE_KEY_CONFIRM => {
+            drop(state);
+            app.event_log(LogEvent::ReceiveValidKeyConfirm(&session), current_time);
+            let mut state = session.state.write().unwrap();
+            // We only want to stop sending NoiseKKPattern2 offers when the latest derived
+            // key is confirmed. And we only want to do that once.
+            let (used_latest_key, try_delete, ret) = match &state.outgoing_offer {
+                NoiseKKPattern2 { .. } => (true, true, SessionEvent::Control),
+                NoiseXKPattern1or3(handshake_state) => {
+                    if let NoiseXKAliceHandshakeState::NoiseXKPattern3 { .. } = &handshake_state.offer {
+                        (true, true, SessionEvent::Established)
+                    } else {
+                        (false, false, SessionEvent::Control)
+                    }
+                }
+                Null => (false, false, SessionEvent::Control),
+                _ => (true, false, SessionEvent::Control),
+            };
+            if try_delete {
+                let result = if !state.ratchet_states[1].is_null() {
+                    app.save_ratchet_state(
+                        &session.remote_static_key,
+                        &session.application_data,
+                        [&state.ratchet_states[0], &state.ratchet_states[1]],
+                        [&state.ratchet_states[0], &RatchetState::Null],
+                        current_time,
+                    )
+                } else {
+                    Ok(())
+                };
+                if let Err(e) = result {
+                    return Err(ReceiveError::RatchetIoError(e));
+                }
+                if let NoiseKKPattern2 { kex_send_key, .. } = &state.outgoing_offer {
+                    session
+                        .kex_send_cipher
+                        .lock()
+                        .unwrap()
+                        .replace(Application::AeadEnc::new(kex_send_key.as_ref()));
+                }
+                state.ratchet_states[1] = RatchetState::Null;
+                state.current_key ^= 1;
+                state.outgoing_offer = new_normal_state(context.0.rng.lock().unwrap().next_u64(), current_time);
+            }
+            drop(state);
+            drop(kex_lock);
+            if used_latest_key {
+                if let Some((send, _)) = send_to(&session) {
+                    let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_ACK, &[]);
+                }
+            }
+            Ok(ReceiveResult::Session(session, ret))
+        }
+        PACKET_TYPE_ACK => {
+            if let KeyConfirm { .. } = &state.outgoing_offer {
+                drop(state);
+                app.event_log(LogEvent::ReceiveValidAck(&session), current_time);
+                let mut state = session.state.write().unwrap();
+                // Check if we should end any current offers and transition back to Normal state
+                state.outgoing_offer = new_normal_state(context.0.rng.lock().unwrap().next_u64(), current_time);
+                drop(kex_lock);
+                drop(state);
+                Ok(ReceiveResult::Session(session, SessionEvent::Control))
+            } else {
+                // This can occur naturally because of control packet resends.
+                Err(byzantine_fault!(FaultType::OutOfSequence, true))
+            }
+        }
+        PACKET_TYPE_NOISE_KK_PATTERN_1 => {
+            app.event_log(LogEvent::ReceiveUncheckedKK1, current_time);
+            let message = &mut message[..NoiseKKPattern1or2::SIZE];
+            let noise_pattern1: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
+            // We need the following operation to be atomic with the change of offer type
+            let (should_rekey_as_bob, chosen_id) = match &state.outgoing_offer {
+                // Check rekey rate limits.
+                Normal { .. } => (true, None),
+                // In the following situation, both parties are in state NoiseKKPattern1,
+                // we need to deterministically allow only one of them to transition to
+                // NoiseKKPattern2.
+                NoiseKKPattern1 { new_key_id, .. } => (session.was_bob, Some(*new_key_id)),
+                _ => (false, None),
+            };
+            if !should_rekey_as_bob {
+                // This can be triggered if both parties attempt rekeying simultaneously, or if the
+                // remote party sent us a duplicate rekey request.
+                // The code above handles this case and only lets one party through to rekeying.
+                drop(state);
+                drop(kex_lock);
+                return Ok(ReceiveResult::Session(session, SessionEvent::Control));
+            }
+            // Noise process pattern1 psk0 token.
+            let sha512 = &mut Application::Hash::new();
+            let hmac = &mut Application::HmacHash::new();
+            let mut noise_ck = SymmetricState::new(INITIAL_H_REKEY);
+            let noise_temp_h = noise_ck.mix_key_and_hash(hmac, state.ratchet_states[0].key().unwrap());
+            let noise_h_psk = mix_hash(sha512, &session.noise_kk_remote_init_h, &noise_temp_h);
+            // Noise process pattern1 e token.
+            // Get public key validation out of the way early
+            let mut noise_es = Secret::new();
+            let mut noise_ee = Secret::new();
+            let mut noise_se = Secret::new();
+            if let Some(alice_e) = from_bytes_agreement::<Application>(&noise_pattern1.noise_e, &context.0.static_keypair, noise_es.as_mut()) {
+                let bob_e_secret = Application::KeyPair::generate(&mut context.0.rng.lock().unwrap());
+                if bob_e_secret.agree(&alice_e, noise_ee.as_mut()) && bob_e_secret.agree(&session.remote_static_key, noise_se.as_mut()) {
+                    let noise_h_pske = mix_hash(sha512, &noise_h_psk, alice_e.as_bytes());
+                    noise_ck.mix_key(hmac, alice_e.as_bytes());
+                    // Noise process pattern1 es token.
+                    noise_ck.mix_key(hmac, noise_es.as_ref());
+                    drop(noise_es);
+                    // Noise process pattern1 ss token.
+                    let noise_k_pskesss = noise_ck.mix_key_initialize_key(hmac, session.noise_kk_ss.as_ref());
+
+                    // Noise process pattern1 payload.
+                    let (is_auth, noise_h_pskep) = decrypt_and_hash::<Application>(
+                        sha512,
+                        &noise_k_pskesss,
+                        &noise_h_pske,
+                        packet_type,
+                        0,
+                        &mut message[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
+                    );
+                    let noise_pattern1: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
+                    if let (true, Some(remote_key_id)) = (is_auth, NonZeroU32::new(u32::from_ne_bytes(noise_pattern1.key_id))) {
+                        // Alice fully authenticated.
+                        // Start of Noise KKpsk0 pattern2.
+                        // Noise process pattern2 e token.
+                        let noise_h_pskepe = mix_hash(sha512, &noise_h_pskep, bob_e_secret.public_key_bytes());
+                        noise_ck.mix_key(hmac, bob_e_secret.public_key_bytes());
+                        // Noise process pattern2 ee token.
+                        noise_ck.mix_key(hmac, noise_ee.as_ref());
+                        drop(noise_ee);
+                        // Noise process pattern2 se token.
+                        let noise_k_pskessseese = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
+                        drop(noise_se);
+                        // Noise process pattern2 payload.
+                        let mut message2 = [0u8; NoiseKKPattern1or2::SIZE];
+                        let noise_pattern2: &mut NoiseKKPattern1or2 = byte_array_as_proto_buffer_mut(&mut message2);
+                        noise_pattern2.noise_e = *bob_e_secret.public_key_bytes();
+                        let mut session_map = context.0.session_map.write().unwrap();
+                        // If we already generated a new key id mapping reuse it.
+                        let new_key_id = chosen_id.unwrap_or_else(|| generate_key_id(&session_map, &mut context.0.rng.lock().unwrap()));
+                        noise_pattern2.key_id = new_key_id.get().to_ne_bytes();
+
+                        let noise_h_pskepep = encrypt_and_hash::<Application>(
+                            sha512,
+                            &noise_k_pskessseese,
+                            &noise_h_pskepe,
+                            PACKET_TYPE_NOISE_KK_PATTERN_2,
+                            0,
+                            &mut message2[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
+                        );
+                        drop(noise_k_pskessseese);
+                        // Bob finished Noise KKpsk0 handshake.
+                        let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_pskepep);
+                        let new_ratchet_state = RatchetState::new_nonempty(rk, rf, NonZeroU64::new(state.ratchet_states[0].chain_len() + 1).unwrap());
+                        let result = app.save_ratchet_state(
+                            &session.remote_static_key,
+                            &session.application_data,
+                            [&state.ratchet_states[0], &state.ratchet_states[1]],
+                            [&new_ratchet_state, &state.ratchet_states[0]],
+                            current_time,
+                        );
+                        if let Err(e) = result {
+                            drop(state);
+                            drop(kex_lock);
+                            return Err(ReceiveError::RatchetIoError(e));
+                        }
+                        let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_pskepep);
+                        // The new "Bob" doesn't know yet if Alice has received the new key, so the
+                        // new key is recorded as the "alt" (key_index ^ 1) but the current key is
+                        // not advanced yet.
+                        let next_key_index = state.current_key ^ 1;
+                        session_map.insert(new_key_id, (Arc::downgrade(&session), next_key_index > 0));
+                        if let Some(pre_id) = state.cipher_states[next_key_index].as_ref().map(|k| k.local_key_id) {
+                            session_map.remove(&pre_id);
+                        }
+                        drop(session_map);
+                        drop(state);
+                        let mut state = session.state.write().unwrap();
+                        let current_counter = session.send_counter.load(Ordering::Relaxed);
+                        session
+                            .kex_receive_cipher
+                            .lock()
+                            .unwrap()
+                            .replace(Application::AeadDec::new(kex_key_a2b.as_ref()));
+                        state.ratchet_states[1] = state.ratchet_states[0].clone();
+                        state.ratchet_states[0] = new_ratchet_state.clone();
+
+                        state.cipher_states[next_key_index].replace(SessionKey::new(
+                            hmac,
+                            noise_ck,
+                            new_key_id,
+                            remote_key_id,
+                            current_counter,
+                            true,
+                        ));
+                        let timer = current_time.saturating_add(Application::RETRY_INTERVAL_MS);
+                        state.outgoing_offer = NoiseKKPattern2 {
+                            next_retry_time: AtomicI64::new(timer),
+                            timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
+                            noise_message: message2,
+                            kex_send_key: kex_key_b2a.clone(),
+                        };
+                        drop(state);
+                        drop(kex_lock);
+                        context.0.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timer));
+
+                        if let Some((send, _)) = send_to(&session) {
+                            let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_NOISE_KK_PATTERN_2, &message2);
+                        }
+                        app.event_log(LogEvent::ReceiveValidKK1(&session), current_time);
+                        return Ok(ReceiveResult::Session(session, SessionEvent::Control));
+                    }
+                }
+            }
+            Err(byzantine_fault!(FaultType::FailedAuthentication, false))
+        }
+        PACKET_TYPE_NOISE_KK_PATTERN_2 => {
+            app.event_log(LogEvent::ReceiveUncheckedKK2, current_time);
+            let message = &mut message[..NoiseKKPattern1or2::SIZE];
+            let noise_pattern2: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
+
+            if let NoiseKKPattern1 { new_key_id, noise_e_secret, noise_ck, noise_h_pskep, .. } = &state.outgoing_offer {
+                // Noise process pattern2 e token.
+                let mut noise_ee = Secret::new();
+                let mut noise_se = Secret::new();
+                if let Some(bob_e) = from_bytes_agreement::<Application>(&noise_pattern2.noise_e, noise_e_secret, noise_ee.as_mut()) {
+                    if context.0.static_keypair.agree(&bob_e, noise_se.as_mut()) {
+                        let sha512 = &mut Application::Hash::new();
+                        let hmac = &mut Application::HmacHash::new();
+                        let mut noise_ck = noise_ck.clone();
+                        let noise_h_pskepe = mix_hash(sha512, noise_h_pskep, bob_e.as_bytes());
+                        noise_ck.mix_key(hmac, bob_e.as_bytes());
+                        // Noise process pattern2 ee token.
+                        noise_ck.mix_key(hmac, noise_ee.as_ref());
+                        drop(noise_ee);
+                        // Noise process pattern2 se token.
+                        let noise_k_pskessseese = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
+                        drop(noise_se);
+                        // Noise process pattern2 payload.
+                        let (is_auth, noise_h_pskepep) = decrypt_and_hash::<Application>(
+                            sha512,
+                            &noise_k_pskessseese,
+                            &noise_h_pskepe,
+                            packet_type,
+                            0,
+                            &mut message[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
+                        );
+                        let noise_pattern2: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
+                        if let (true, Some(remote_key_id)) = (is_auth, NonZeroU32::new(u32::from_ne_bytes(noise_pattern2.key_id))) {
+                            // Bob fully authenticated.
+                            // Alice finished Noise KKpsk0 handshake.
+                            let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_pskepep);
+                            let new_ratchet_state =
+                                RatchetState::new_nonempty(rk, rf, NonZeroU64::new(state.ratchet_states[0].chain_len() + 1).unwrap());
+                            let result = app.save_ratchet_state(
+                                &session.remote_static_key,
+                                &session.application_data,
+                                [&state.ratchet_states[0], &state.ratchet_states[1]],
+                                [&new_ratchet_state, &RatchetState::Null],
+                                current_time,
+                            );
+                            if let Err(e) = result {
+                                drop(state);
+                                drop(kex_lock);
+                                return Err(ReceiveError::RatchetIoError(e));
+                            }
+                            let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_pskepep);
+
+                            let new_key_id = *new_key_id;
+                            drop(state);
+                            let mut state = session.state.write().unwrap();
+                            let next_key_index = state.current_key ^ 1;
+                            state.current_key = next_key_index;
+                            if let Some(key) = state.cipher_states[next_key_index].as_ref() {
+                                context.0.session_map.write().unwrap().remove(&key.local_key_id);
+                            }
+                            session
+                                .kex_receive_cipher
+                                .lock()
+                                .unwrap()
+                                .replace(Application::AeadDec::new(kex_key_b2a.as_ref()));
+                            session
+                                .kex_send_cipher
+                                .lock()
+                                .unwrap()
+                                .replace(Application::AeadEnc::new(kex_key_a2b.as_ref()));
+                            state.ratchet_states[1] = RatchetState::Null;
+                            state.ratchet_states[0] = new_ratchet_state.clone();
+
+                            state.cipher_states[next_key_index].replace(SessionKey::new(
+                                hmac,
+                                noise_ck,
+                                new_key_id,
+                                remote_key_id,
+                                session.send_counter.load(Ordering::Relaxed),
+                                false,
+                            ));
+                            state.outgoing_offer = KeyConfirm {
+                                next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
+                                timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
+                            };
+                            drop(state);
+                            drop(kex_lock);
+                            // Let Bob know we got the key.
+                            if let Some((send, _)) = send_to(&session) {
+                                let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_KEY_CONFIRM, &[]);
+                            }
+                            app.event_log(LogEvent::ReceiveValidKK2(&session), current_time);
+                            return Ok(ReceiveResult::Session(session, SessionEvent::Control));
+                        }
+                    }
+                }
+                // Bob failed authentication so according to Noise we must terminate this
+                // handshake.
+                // This should not happen in practice since this packet will have already passed
+                // authentication under the current key.
+                session.expire();
+                Err(byzantine_fault!(FaultType::FailedAuthentication, false))
+            } else {
+                drop(state);
+                drop(kex_lock);
+                Ok(ReceiveResult::Session(session, SessionEvent::Control))
+            }
+        }
+        _ => Err(byzantine_fault!(FaultType::InvalidPacket, false)),
+    };
+}
+
+impl<Application: ApplicationLayer> Session<Application> {
+    /// This can only fail with `MaxKeyLifetimeExceeded` or `SessionNotEstablished`.
+    fn send_control(
+        &self,
+        state: &SessionMutableState<Application>,
+        send: impl FnOnce(&mut [u8]) -> bool,
+        packet_type: u8,
+        packet: &[u8],
+    ) -> Result<(), SendError> {
+        let key = state.cipher_states[state.current_key].as_ref().ok_or(SendError::SessionNotEstablished)?;
+        let counter = self.get_next_outgoing_counter()?;
+        let mut c = self.kex_send_cipher.lock().unwrap();
+        let (mut fragment, len) = encrypt_control(
+            c.as_mut().ok_or(SendError::SessionNotEstablished)?,
+            &self.header_send_cipher,
+            packet_type,
+            counter,
+            key.remote_key_id.get(),
+            packet,
+        );
+        send(&mut fragment[..len]);
+        Ok(())
+    }
+    /// Check whether this session is established.
+    pub fn established(&self) -> bool {
+        let state = self.state.read().unwrap();
+        !matches!(&state.outgoing_offer, OfferStateMachine::NoiseXKPattern1or3(_) | OfferStateMachine::Null)
+    }
+    /// The static public key of the remote peer.
+    pub fn remote_s_public_key(&self) -> &Application::PublicKey {
+        &self.remote_static_key
+    }
+    /// The current ratchet state of this session.
+    /// The returned values are sensitive and should be securely erased before being dropped.
+    pub fn ratchet_states(&self) -> [RatchetState; 2] {
+        let state = self.state.read().unwrap();
+        state.ratchet_states.clone()
+    }
+    /// The current ratchet count of this session.
+    pub fn ratchet_count(&self) -> u64 {
+        self.state.read().unwrap().ratchet_states[0].chain_len()
+    }
+    /// Mark a session as expired. This will make it impossible for this session to successfully
+    /// receive or send data or control packets. It is recommended to simply `drop` the session
+    /// instead, but this can provide some reassurance in complex shared ownership situations.
+    pub fn expire(&self) {
+        if let Some(context) = self.context.upgrade() {
+            self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
+        }
+    }
+    fn expire_inner(
+        &self,
+        context: &Arc<ContextInner<Application>>,
+        session_queue: &mut IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>,
+    ) {
+        // Prevent this session from being updated.
+        session_queue.remove(self.queue_idx);
+        self.session_has_expired.store(true, Ordering::Relaxed);
+        let _kex_lock = self.state_machine_lock.lock().unwrap();
+        let mut state = self.state.write().unwrap();
+        let mut session_map = context.session_map.write().unwrap();
+        for key in &state.cipher_states {
+            if let Some(pre_id) = key.as_ref().map(|k| k.local_key_id) {
+                session_map.remove(&pre_id);
+            }
+        }
+        use OfferStateMachine::*;
+        match &state.outgoing_offer {
+            NoiseXKPattern1or3(handshake_state) => session_map.remove(&handshake_state.local_key_id),
+            NoiseKKPattern1 { new_key_id, .. } => session_map.remove(new_key_id),
+            _ => None,
+        };
+        state.outgoing_offer = OfferStateMachine::Null;
+    }
+
+    /// Get the next outgoing counter value.
+    fn get_next_outgoing_counter(&self) -> Result<u64, SendError> {
+        if self.session_has_expired.load(Ordering::Relaxed) {
+            Err(SendError::SessionExpired)
+        } else {
+            let counter = self.send_counter.fetch_add(1, Ordering::Relaxed);
+            if counter > THREAD_SAFE_COUNTER_HARD_EXPIRE {
+                // Because this thread sets the flag itself it will never be able to increment the
+                // counter again.
+                // For that reason the other atomic orderings can be `Relaxed`.
+                self.session_has_expired.store(true, Ordering::SeqCst)
+            }
+            Ok(counter)
+        }
+    }
+    /// Check the receive window without mutating state.
+    fn check_receive_window(&self, counter: u64) -> bool {
+        let slot = &self.counter_antireplay_window[(counter as usize) % self.counter_antireplay_window.len()];
+        let counter = counter.wrapping_add(1);
+        let prev_counter = slot.load(Ordering::Relaxed);
+        prev_counter < counter && counter.wrapping_sub(prev_counter) <= COUNTER_WINDOW_MAX_SKIP_AHEAD
+    }
+    /// Update the receive window, returning true if the packet is still valid.
+    /// This should only be called after the packet is authenticated.
+    fn update_receive_window(&self, counter: u64) -> bool {
+        let slot = &self.counter_antireplay_window[(counter as usize) % self.counter_antireplay_window.len()];
+        let counter = counter.wrapping_add(1);
+        let prev_counter = slot.fetch_max(counter, Ordering::Relaxed);
+        prev_counter < counter && counter.wrapping_sub(prev_counter) <= COUNTER_WINDOW_MAX_SKIP_AHEAD
+    }
+}
+impl<Application: ApplicationLayer> Drop for Session<Application> {
+    fn drop(&mut self) {
+        if let Some(context) = self.context.upgrade() {
+            self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
+        }
+    }
+}
+
+impl<Application: ApplicationLayer> NoiseXKAliceHandshake<Application> {
+    /// Can only fail with `OpenError::InvalidPublicKey` because of remote_s_public_key.
+    /// Corresponds to Noise `Initialize`.
+    fn initialize(
+        local_key_id: NonZeroU32,
+        remote_s_public_key: &Application::PublicKey,
+        ratchet_state: &[RatchetState; 2],
+        rng: &mut Application::Rng,
+    ) -> Result<
+        (
+            NoiseXKAliceHandshakeState<Application>,
+            Secret<AES_GCM_KEY_SIZE>,
+            Secret<AES_GCM_KEY_SIZE>,
+        ),
+        OpenError<Application::StorageError>,
+    > {
+        let mut message = [0u8; NoiseXKPattern1::MAX_SIZE];
+        let sha512 = &mut Application::Hash::new();
+        let hmac = &mut Application::HmacHash::new();
+        // Start of Noise XKhfs+psk2 pattern1.
+        let noise_pattern1: &mut NoiseXKPattern1 = byte_array_as_proto_buffer_mut(&mut message);
+        let noise_e_secret = Application::KeyPair::generate(rng);
+        let noise_e1_secret = pqc_kyber::keypair(rng);
+        noise_pattern1.alice_key_id = local_key_id.get().to_ne_bytes();
+        noise_pattern1.noise_e = *noise_e_secret.public_key_bytes();
+        noise_pattern1.noise_e1 = noise_e1_secret.public;
+        // Noise process prologue.
+        let noise_h = mix_hash(
+            sha512,
+            &INITIAL_H,
+            &message[NoiseXKPattern1::PROLOGUE_START..NoiseXKPattern1::PROLOGUE_END],
+        );
+        let noise_h = mix_hash(sha512, &noise_h, remote_s_public_key.as_bytes());
+        // Noise process pattern1 e token.
+        let mut noise_ck = SymmetricState::new(INITIAL_H);
+        let noise_h_e = mix_hash(sha512, &noise_h, noise_e_secret.public_key_bytes());
+        noise_ck.mix_key(hmac, noise_e_secret.public_key_bytes());
+        // Noise process pattern1 es token.
+        let mut noise_es = Secret::new();
+        if !noise_e_secret.agree(remote_s_public_key, noise_es.as_mut()) {
+            return Err(OpenError::InvalidPublicKey);
+        }
+        let noise_k_es = noise_ck.mix_key_initialize_key(hmac, noise_es.as_ref());
+        drop(noise_es);
+        // Noise process pattern1 e1 token.
+        let noise_h_ee1 = encrypt_and_hash::<Application>(
+            sha512,
+            &noise_k_es,
+            &noise_h_e,
+            PACKET_TYPE_NOISE_XK_PATTERN_1,
+            0,
+            &mut message[NoiseXKPattern1::E1_ENC_START..NoiseXKPattern1::P_ENC_START],
+        );
+        // Noise process pattern1 payload.
+        let noise_pattern1: &mut NoiseXKPattern1 = byte_array_as_proto_buffer_mut(&mut message);
+        let mut idx = 0;
+        for rs in ratchet_state {
+            if let Some(rf) = rs.fingerprint() {
+                let next_idx = idx + RATCHET_SIZE;
+                noise_pattern1.payload[idx..next_idx].copy_from_slice(rf);
+                idx = next_idx;
+            }
+        }
+        let p_auth_end = NoiseXKPattern1::P_ENC_START + idx + AES_GCM_TAG_SIZE;
+        let noise_message_len = p_auth_end + ChallengeResponse::SIZE;
+
+        let noise_h_ee1p = encrypt_and_hash::<Application>(
+            sha512,
+            &noise_k_es,
+            &noise_h_ee1,
+            PACKET_TYPE_NOISE_XK_PATTERN_1,
+            1,
+            &mut message[NoiseXKPattern1::P_ENC_START..p_auth_end],
+        );
+        drop(noise_k_es);
+        let (header_b2a_key, header_a2b_key) = noise_ck.get_ask2(hmac, LABEL_HEADER_KEY, &noise_h_ee1p);
+        let message_id = u64::from_be_bytes(message[p_auth_end - 8..p_auth_end].try_into().unwrap());
+
+        message[noise_message_len - CHALLENGE_POW_SIZE..noise_message_len].copy_from_slice(&rng.next_u64().to_ne_bytes());
+        Ok((
+            NoiseXKAliceHandshakeState::NoiseXKPattern1 {
+                noise_h_ee1p,
+                noise_e_secret,
+                noise_e1_secret: Secret(noise_e1_secret.secret),
+                noise_ck_es: noise_ck,
+                noise_message_len,
+                noise_message: message,
+                message_id,
+            },
+            header_a2b_key,
+            header_b2a_key,
+        ))
+    }
+    /// Should not fail unless Bob's public key is adversarial.
+    fn reinitialize(
+        &mut self,
+        session: &Arc<Session<Application>>,
+        ratchet_state: &[RatchetState; 2],
+        session_map: &mut HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>,
+        rng: &mut Application::Rng,
+        current_time: i64,
+    ) -> bool {
+        let local_key_id = generate_key_id(session_map, rng);
+        if let Ok((offer, a2b_header_key, b2a_header_key)) = Self::initialize(local_key_id, &session.remote_static_key, ratchet_state, rng) {
+            self.timeout = current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS);
+            session_map.remove(&self.local_key_id);
+            session_map.insert(local_key_id, (Arc::downgrade(session), false));
+            self.local_key_id = local_key_id;
+            self.offer = offer;
+            session.header_send_cipher.reset(a2b_header_key.as_ref());
+            session.header_receive_cipher.reset(b2a_header_key.as_ref());
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/// Create the normal state of the offer state machine, with the correct timestamps.
+fn new_normal_state<Application: ApplicationLayer>(rand: u64, current_time: i64) -> OfferStateMachine<Application> {
+    OfferStateMachine::Normal {
+        timeout: current_time
+            .saturating_add(Application::REKEY_AFTER_TIME_MS)
+            .saturating_sub(rand as i64 % Application::REKEY_AFTER_TIME_MAX_JITTER_MS),
+    }
+}
+/// Get a timestamp of when this timer should trigger next, or None if it should trigger now.
+fn process_timer(timer: &AtomicI64, wait_time: i64, current_time: i64) -> Option<i64> {
+    let ts = timer.load(Ordering::Relaxed);
+    if ts <= current_time && timer.fetch_max(ts.saturating_add(wait_time), Ordering::Relaxed) == ts {
+        None
+    } else {
+        Some(ts)
+    }
+}
+
+/// Corresponds to Noise `EncryptAndHash`.
+fn encrypt_and_hash<Application: ApplicationLayer>(
+    sha512: &mut Application::Hash,
+    noise_k: &Secret<AES_GCM_KEY_SIZE>,
+    noise_h: &[u8; HASHLEN],
+    packet_type: u8,
+    noise_k_uses: u64,
+    message: &mut [u8],
+) -> [u8; HASHLEN] {
+    let auth_start = message.len() - AES_GCM_TAG_SIZE;
+    let mut gcm = Application::AeadEnc::new(noise_k.as_ref());
+    // Encrypt and add authentication tag.
+    gcm.set_iv(&create_message_nonce(packet_type, INIT_COUNTER + noise_k_uses));
+    gcm.set_aad(noise_h);
+    if auth_start > 0 {
+        gcm.encrypt_in_place(&mut message[..auth_start]);
+    }
+    gcm.finish_encrypt((&mut message[auth_start..]).try_into().unwrap());
+    mix_hash(sha512, noise_h, message)
+}
+/// Corresponds to Noise `DecryptAndHash`.
+fn decrypt_and_hash<Application: ApplicationLayer>(
+    sha512: &mut Application::Hash,
+    noise_k: &Secret<AES_GCM_KEY_SIZE>,
+    noise_h: &[u8; HASHLEN],
+    packet_type: u8,
+    noise_k_uses: u64,
+    message: &mut [u8],
+) -> (bool, [u8; HASHLEN]) {
+    let auth_start = message.len() - AES_GCM_TAG_SIZE;
+    let noise_h_c = mix_hash(sha512, noise_h, message);
+    let mut gcm = Application::AeadDec::new(noise_k.as_ref());
+    gcm.set_iv(&create_message_nonce(packet_type, INIT_COUNTER + noise_k_uses));
+    gcm.set_aad(noise_h);
+    if auth_start > 0 {
+        gcm.decrypt_in_place(&mut message[..auth_start]);
+    }
+    (gcm.finish_decrypt((&message[auth_start..]).try_into().unwrap()), noise_h_c)
+}
+/// Encrypt a standardized control packet.
+fn encrypt_control(
+    c: &mut impl AesGcmEnc,
+    header_cipher: &impl AesEnc,
+    packet_type: u8,
+    counter: u64,
+    remote_key_id: u32,
+    packet: &[u8],
+) -> ([u8; CONTROL_PACKET_MAX_SIZE], usize) {
+    let mut fragment = [0u8; CONTROL_PACKET_MAX_SIZE];
+    let fragment_len = packet.len() + HEADER_SIZE + AES_GCM_TAG_SIZE;
+
+    c.set_iv(&create_message_nonce(packet_type, counter));
+    if !packet.is_empty() {
+        fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE].copy_from_slice(packet);
+        c.encrypt_in_place(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE]);
+    }
+    c.finish_encrypt((&mut fragment[fragment_len - AES_GCM_TAG_SIZE..fragment_len]).try_into().unwrap());
+    set_packet_header(&mut fragment, 1, 0, packet_type, remote_key_id, counter);
+    header_cipher.encrypt_in_place((&mut fragment[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END]).try_into().unwrap());
+    (fragment, fragment_len)
+}
+fn decrypt_control<'a, IoError>(
+    c: &mut impl AesGcmDec,
+    packet_type: u8,
+    counter: u64,
+    fragment: &'a mut [u8],
+) -> Result<&'a mut [u8], ReceiveError<IoError>> {
+    let fragment_len = fragment.len();
+    if !(CONTROL_PACKET_MIN_SIZE..=CONTROL_PACKET_MAX_SIZE).contains(&fragment_len) {
+        return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+    }
+    c.set_iv(&create_message_nonce(packet_type, counter));
+    c.decrypt_in_place(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE]);
+    if !c.finish_decrypt((&fragment[fragment_len - AES_GCM_TAG_SIZE..fragment_len]).try_into().unwrap()) {
+        // This can occur naturally if one of the remote peers resent a
+        // control packet that got delayed and arrived out of order.
+        return Err(byzantine_fault!(FaultType::FailedAuthentication, true));
+    }
+    Ok(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE])
+}
+
+fn set_packet_header(packet: &mut [u8], fragment_count: u8, fragment_no: u8, packet_type: u8, remote_key_id: u32, counter_or_id: u64) {
+    debug_assert!(packet.len() >= MIN_PACKET_SIZE);
+    debug_assert!(fragment_count > 0);
+    debug_assert!(fragment_count <= MAX_FRAGMENTS as u8);
+    debug_assert!(fragment_no < MAX_FRAGMENTS as u8);
+    debug_assert_eq!((packet_type << 1) >> 1, packet_type);
+    // [0..4]   recipient key id
+    // -- start AES(ck_es * h_e_e1_p) encrypted block --
+    // [4]      fragment count (1..255)
+    // [5]      fragment number (0..254)
+    // [6]      reserved zero
+    // -- start of AES-GCM Nonce --
+    // [7]      packet type
+    // [8..16]  64-bit counter or packet id (big endian)
+    packet[4..16].copy_from_slice(&create_message_nonce(packet_type, counter_or_id));
+    packet[0..4].copy_from_slice(&remote_key_id.to_ne_bytes());
+    packet[4] = fragment_count;
+    packet[5] = fragment_no;
+    packet[6] = 0;
+}
+/// Create a 96-bit AES-GCM nonce.
+///
+/// The primary information that we want to be contained here is the counter and the
+/// packet type. The former makes this unique and the latter's inclusion authenticates
+/// it as effectively AAD. Other elements of the header are either not authenticated,
+/// like fragmentation info, or their authentication is implied via key exchange like
+/// the key id.
+fn create_message_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
+    let mut ret = [0u8; AES_GCM_IV_SIZE];
+    ret[3] = packet_type;
+    // Noise requires a big endian counter at the end of the Nonce
+    ret[4..].copy_from_slice(&counter.to_be_bytes());
+    ret
+}
+/// returns `(fragment_count, fragment_no, packet_type, counter, header_nonce)`.
+fn parse_packet_header(packet: &[u8]) -> (u8, u8, u8, u64, [u8; 10]) {
+    let header_nonce = packet[6..16].try_into().unwrap();
+    let counter = packet[8..16].try_into().unwrap();
+    // We intentionally ignore the version number for future revisions.
+    (packet[4], packet[5], packet[7], u64::from_be_bytes(counter), header_nonce)
+}
+
+/// Break a packet into fragments and send them all.
+///
+/// The contents of packet[] are mangled during this operation, so it should be discarded after.
+/// This is only used for key exchange and control packets. For data packets this is done inline
+/// for better performance with encryption and fragmentation happening at the same time.
+fn send_with_fragmentation(
+    send: &mut impl FnMut(&mut [u8]) -> bool,
+    mtu: usize,
+    packet: &mut [u8],
+    packet_type: u8,
+    remote_key_id: Option<NonZeroU32>,
+    counter_or_id: u64,
+    header_cipher: Option<&impl AesEnc>,
+) -> bool {
+    let packet_len = packet.len();
+    let fragment_count = (packet_len.saturating_add(mtu - 1)) / mtu; // integer ceiling divide
+    debug_assert!(fragment_count <= MAX_FRAGMENTS);
+    let mut fragment_start = 0;
+    let mut fragment_end = packet_len.min(mtu);
+    let mut fragment_no = 0;
+    loop {
+        let fragment = &mut packet[fragment_start..fragment_end];
+        set_packet_header(
+            fragment,
+            fragment_count as u8,
+            fragment_no as u8,
+            packet_type,
+            remote_key_id.map_or(0, |n| n.get()),
+            counter_or_id,
+        );
+        if let Some(hcc) = header_cipher {
+            hcc.encrypt_in_place((&mut fragment[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END]).try_into().unwrap());
+        }
+        if !send(fragment) {
+            return false;
+        }
+        fragment_no += 1;
+        if fragment_no < fragment_count {
+            fragment_start = fragment_end - HEADER_SIZE;
+            fragment_end = (fragment_start.saturating_add(mtu)).min(packet_len);
+        } else {
+            break;
+        }
+    }
+    true
+}
+
+/// Assemble a series of fragments into a buffer and return the length of the assembled packet in
+/// bytes.
+///
+/// This is also only used for key exchange and control packets. For data packets decryption and
+/// assembly happen in one pass for better performance.
+fn assemble_fragments_into<A: ApplicationLayer>(fragments: &[A::IncomingPacketBuffer], d: &mut [u8]) -> Result<usize, ReceiveError<A::StorageError>> {
+    let mut l = 0;
+    for i in 0..fragments.len() {
+        let mut ff = fragments[i].as_ref();
+        if i > 0 {
+            ff = &ff[HEADER_SIZE..];
+        }
+        let j = l + ff.len();
+        if j > d.len() {
+            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+        }
+        d[l..j].copy_from_slice(ff);
+        l = j;
+    }
+    Ok(l)
+}
+/// Generate a random local key id that is currently unused.
+fn generate_key_id<Application: ApplicationLayer>(
+    session_map: &HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>,
+    rng: &mut Application::Rng,
+) -> NonZeroU32 {
+    loop {
+        if let Some(local_key_id) = NonZeroU32::new(rng.next_u32()) {
+            if !session_map.contains_key(&local_key_id) {
+                return local_key_id;
+            }
+        }
+    }
+}
+
+impl<Application: ApplicationLayer> SessionKey<Application> {
+    fn new(
+        hmac: &mut Application::HmacHash,
+        ck: SymmetricState,
+        local_key_id: NonZeroU32,
+        remote_key_id: NonZeroU32,
+        current_counter: u64,
+        is_bob: bool,
+    ) -> Self {
+        let (b2a, a2b) = ck.split(hmac);
+        let (receive_key, send_key) = if is_bob {
+            (&a2b, &b2a)
+        } else {
+            (&b2a, &a2b)
+        };
+        let send_cipher_pool = std::array::from_fn(|_| Mutex::new(Application::AeadEnc::new(send_key.as_ref())));
+        let receive_cipher_pool = std::array::from_fn(|_| Mutex::new(Application::AeadDec::new(receive_key.as_ref())));
+        Self {
+            local_key_id,
+            remote_key_id,
+            send_cipher_pool,
+            receive_cipher_pool,
+            rekey_at_counter: current_counter.saturating_add(Application::REKEY_AFTER_USES),
+            expire_at_counter: current_counter.saturating_add(Application::EXPIRE_AFTER_USES),
+        }
+    }
+
+    fn get_send_cipher(&self, counter: u64) -> Result<MutexGuard<Application::AeadEnc>, SendError> {
+        if counter < self.expire_at_counter {
+            Ok(self.send_cipher_pool[(counter as usize) % self.send_cipher_pool.len()].lock().unwrap())
+        } else {
+            Err(SendError::SessionExpired)
+        }
+    }
+
+    fn get_receive_cipher(&self, counter: u64) -> MutexGuard<Application::AeadDec> {
+        let idx = (counter as usize) % self.receive_cipher_pool.len();
+        self.receive_cipher_pool[idx].lock().unwrap()
+    }
+}
+
+/// MixHash to update 'h' during negotiation.
+fn mix_hash(hasher: &mut impl Sha512, h: &[u8; HASHLEN], m: &[u8]) -> [u8; HASHLEN] {
+    let mut output = [0u8; HASHLEN];
+    hasher.reset();
+    hasher.update(h);
+    hasher.update(m);
+    hasher.finish(&mut output);
+    output
+}
+/// Check if the proof of work attached to the first message contains the correct number of leading
+/// zeros.
+fn verify_pow<Application: ApplicationLayer>(hasher: &mut Application::Hash, response: &[u8]) -> bool {
+    if Application::PROOF_OF_WORK_BIT_DIFFICULTY == 0 {
+        return true;
+    }
+    hasher.reset();
+    hasher.update(response);
+    let mut output = [0u8; HASHLEN];
+    hasher.finish(&mut output);
+    let n = u32::from_be_bytes(output[..4].try_into().unwrap());
+    n.leading_zeros() >= Application::PROOF_OF_WORK_BIT_DIFFICULTY
+}
+fn from_bytes_agreement<Application: ApplicationLayer>(
+    public: &[u8],
+    private: &Application::KeyPair,
+    output: &mut [u8; P384_ECDH_SHARED_SECRET_SIZE],
+) -> Option<Application::PublicKey> {
+    Application::PublicKey::from_bytes(public.try_into().unwrap()).and_then(|e| private.agree(&e, output).then_some(e))
+}
diff --git a/src/zssp.rs b/src/zssp.rs
index 98f9a3f..2288a43 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -16,15 +16,17 @@ use std::ops::DerefMut;
 use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex, MutexGuard, RwLock, Weak};
 
-use crate::crypto::aes::{AesDec, AesEnc};
-use crate::crypto::aes_gcm::{AesGcmDec, AesGcmEnc, AES_GCM_IV_SIZE, AES_GCM_KEY_SIZE, AES_GCM_TAG_SIZE};
+use arrayvec::ArrayVec;
+use zeroize::Zeroizing;
+
+use crate::challenge::ChallengeContext;
+use crate::crypto::aes::{AesDec, AesEnc, AES_256_KEY_SIZE};
 use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
 use crate::crypto::pqc_kyber::KYBER_SECRETKEYBYTES;
 use crate::crypto::rand_core::RngCore;
-use crate::crypto::secret::{secure_eq, Secret};
-use crate::crypto::sha512::{HmacSha512, Sha512};
+use crate::crypto::sha512::{HmacSha512, HashSha512};
 
-use crate::error::{FaultType, OpenError, ReceiveError, SendError};
+use crate::result::{FaultType, OpenError, ReceiveError, SendError};
 use crate::frag_cache::UnassociatedFragCache;
 use crate::fragged::{Assembled, Fragged};
 use crate::handshake_cache::UnassociatedHandshakeCache;
@@ -53,9 +55,7 @@ pub struct ContextInner<Application: ApplicationLayer> {
     /// `session_queue -> state_machine_lock -> state -> session_map`
     session_queue: Mutex<IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>>,
     session_map: RwLock<HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>>,
-    challenge_counter: AtomicU64,
-    challenge_antireplay_window: [AtomicU64; CHALLENGE_COUNTER_WINDOW_MAX_OOO],
-    challenge_salt: [u8; CHALLENGE_SALT_SIZE],
+    challenge: ChallengeContext,
     rng: Mutex<Application::Rng>,
 }
 
@@ -114,18 +114,18 @@ pub enum IncomingSessionAction {
 /// ZeroTier Secure Session Protocol (ZSSP) Session
 ///
 /// A FIPS/NIST compliant variant of Noise_XK with hybrid Kyber1024 PQ data forward secrecy.
-pub struct Session<Application: ApplicationLayer> {
+pub struct Session<App: ApplicationLayer> {
     /// An arbitrary application defined object associated with each session.
-    pub application_data: Application::Data,
+    pub application_data: App::SessionData,
     /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
     pub was_bob: bool,
     /// The receive context associated with this session,
     /// only this context can receive messages from the remote peer.
-    context: Weak<ContextInner<Application>>,
+    context: Weak<ContextInner<App>>,
     /// Handle into the session queue for changing the update timer.
     queue_idx: BinaryHeapIndex,
 
-    remote_static_key: Application::PublicKey,
+    remote_static_key: App::PublicKey,
     send_counter: AtomicU64,
     /// This bool signals to all threads to stop incrementing the counter and instead error out.
     session_has_expired: AtomicBool,
@@ -137,16 +137,16 @@ pub struct Session<Application: ApplicationLayer> {
     /// it goes `session_queue -> state_machine_lock -> state -> session_map`.
     /// Any lock can be skipped but they must be locked in that order.
     state_machine_lock: Mutex<()>,
-    state: RwLock<SessionMutableState<Application>>,
-    defrag: [Mutex<Fragged<Application::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
-    header_send_cipher: Application::PrpEnc,
-    header_receive_cipher: Application::PrpDec,
-    kex_send_cipher: Mutex<Option<Application::AeadEnc>>,
-    kex_receive_cipher: Mutex<Option<Application::AeadDec>>,
+    state: RwLock<SessionMutableState<App>>,
+    defrag: [Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
+    header_send_cipher: App::PrpEnc,
+    header_receive_cipher: App::PrpDec,
+    kex_send_cipher: Mutex<Zeroizing<[u8; AES_256_KEY_SIZE]>>,
+    kex_receive_cipher: Mutex<Zeroizing<[u8; AES_256_KEY_SIZE]>>,
     /// Pre-computed rekeying values.
-    noise_kk_ss: Secret<P384_ECDH_SHARED_SECRET_SIZE>,
-    noise_kk_local_init_h: [u8; NOISE_HASHLEN],
-    noise_kk_remote_init_h: [u8; NOISE_HASHLEN],
+    noise_kk_ss: Zeroizing<[u8; P384_ECDH_SHARED_SECRET_SIZE]>,
+    noise_kk_local_init_h: [u8; HASHLEN],
+    noise_kk_remote_init_h: [u8; HASHLEN],
 }
 /// `AesGcm` is not threadsafe, but it is threadsafe when inside a `Mutex`.
 unsafe impl<Application: ApplicationLayer> Send for Session<Application> {}
@@ -161,6 +161,8 @@ struct SessionMutableState<Application: ApplicationLayer> {
     /// This is the index of `noise_cipher_state` that contains the most recent key.
     /// It will be attached to fragment headers to help with OOO transport.
     current_key: usize,
+    resent_timer: AtomicI64,
+    timeout_timer: i64,
     /// This defines the exact state of the offer state machine we are in.
     outgoing_offer: OfferStateMachine<Application>,
 }
@@ -168,73 +170,57 @@ struct SessionMutableState<Application: ApplicationLayer> {
 /// These offer enums form a state machine.
 /// Documented below are the only legal transitions for this state machine.
 /// A session is initialized with an `outgoing_offer` of either NoiseXKPattern1 or Normal.
-enum OfferStateMachine<Application: ApplicationLayer> {
-    Normal {
-        timeout: i64,
-    }, // -> NoiseKKPattern1, NoiseKKPattern2
+enum OfferStateMachine<App: ApplicationLayer> {
+    Normal, // -> NoiseKKPattern1, NoiseKKPattern2
     /// This state uses a lot of memory so we put it on the heap.
-    NoiseXKPattern1or3(Box<NoiseXKAliceHandshake<Application>>), // -> Normal
+    NoiseXKPattern1or3(Box<NoiseXKAliceHandshake<App>>), // -> Normal
     NoiseKKPattern1 {
-        next_retry_time: AtomicI64,
-        timeout: i64,
         new_key_id: NonZeroU32,
-        noise_e_secret: Application::KeyPair,
-        noise_message: [u8; NoiseKKPattern1or2::SIZE],
-        noise_ck: SymmetricState,
-        noise_h_pskep: [u8; NOISE_HASHLEN],
+        noise_e_secret: App::KeyPair,
+        noise_message: ArrayVec<u8, REKEY_SIZE>,
+        noise_ck: SymmetricState<App>,
     }, // -> NoiseKKPattern2, KeyConfirm
     NoiseKKPattern2 {
-        next_retry_time: AtomicI64,
-        timeout: i64,
-        noise_message: [u8; NoiseKKPattern1or2::SIZE],
-        kex_send_key: Secret<AES_GCM_KEY_SIZE>,
-    }, // -> Normal
-    KeyConfirm {
-        next_retry_time: AtomicI64,
-        timeout: i64,
+        noise_message: ArrayVec<u8, REKEY_SIZE>,
+        kex_send_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
     }, // -> Normal
+    KeyConfirm, // -> Normal
     Null,
 }
 
-pub(crate) struct NoiseXKBobHandshakeState<Application: ApplicationLayer> {
+pub(crate) struct NoiseXKBobHandshakeState<App: ApplicationLayer> {
     /// Can never be Null.
     ratchet_state: RatchetState,
     remote_key_id: NonZeroU32,
     local_key_id: NonZeroU32,
-    header_receive_key: Secret<AES_GCM_KEY_SIZE>,
-    header_send_key: Secret<AES_GCM_KEY_SIZE>,
-    noise_h_ee1peekem1pskp: [u8; NOISE_HASHLEN],
-    noise_e_secret: Application::KeyPair,
-    noise_ck_eseeekem1psk: SymmetricState,
-    noise_k_eseeekem1psk: Secret<AES_GCM_KEY_SIZE>,
-    noise_pattern3_defrag: Mutex<Fragged<Application::IncomingPacketBuffer, MAX_FRAGMENTS>>,
+    header_receive_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
+    header_send_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
+    noise_e_secret: App::KeyPair,
+    noise_ck_eseeekem1psk: SymmetricState<App>,
+    noise_pattern3_defrag: Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>,
 }
 
-struct NoiseXKAliceHandshake<Application: ApplicationLayer> {
-    next_retry_time: AtomicI64,
-    timeout: i64,
+struct NoiseXKAliceHandshake<App: ApplicationLayer> {
     /// A secure random number put in the header of Alice's fragments to identify them.
     /// If a DDOS attacker could guess this they could block Alice starting the handshake.
     local_key_id: NonZeroU32,
-    alice_identity_blob: Application::LocalIdentityBlob,
-    offer: NoiseXKAliceHandshakeState<Application>,
+    alice_identity_blob: App::LocalIdentityBlob,
+    offer: NoiseXKAliceHandshakeState<App>,
 }
 
-enum NoiseXKAliceHandshakeState<Application: ApplicationLayer> {
+enum NoiseXKAliceHandshakeState<App: ApplicationLayer> {
     NoiseXKPattern1 {
-        noise_h_ee1p: [u8; NOISE_HASHLEN],
-        noise_e_secret: Application::KeyPair,
-        noise_e1_secret: Secret<KYBER_SECRETKEYBYTES>,
-        noise_ck_es: SymmetricState,
+        noise_h_ee1p: [u8; HASHLEN],
+        noise_e_secret: App::KeyPair,
+        noise_e1_secret: App::Kem,
+        noise_ck_es: SymmetricState<App>,
         /// ZSSP assumes an unreliable, out-of-order physical transport environment, so for that
         /// reason we have to resend key offers.
-        noise_message: [u8; NoiseXKPattern1::MAX_SIZE],
-        noise_message_len: usize,
+        noise_message: ArrayVec<u8, HANDSHAKE_HELLO_MAX_SIZE>,
         message_id: u64,
     },
     NoiseXKPattern3 {
-        noise_message: [u8; NoiseXKPattern3::MAX_SIZE],
-        noise_message_len: usize,
+        noise_message: ArrayVec<u8, HANDSHAKE_COMPLETION_MAX_SIZE>,
     },
 }
 
@@ -476,10 +462,10 @@ impl<Application: ApplicationLayer> Context<Application> {
         mut send: impl FnMut(&mut [u8]) -> bool,
         mut mtu: usize,
         remote_static_key: Application::PublicKey,
-        application_data: Application::Data,
+        application_data: Application::SessionData,
         local_identity_blob: Application::LocalIdentityBlob,
         current_time: i64,
-    ) -> Result<Arc<Session<Application>>, OpenError<Application::IoError>> {
+    ) -> Result<Arc<Session<Application>>, OpenError<Application::StorageError>> {
         mtu = mtu.max(MIN_TRANSPORT_MTU);
         if local_identity_blob.as_ref().len() > MAX_IDENTITY_BLOB_SIZE {
             return Err(OpenError::DataTooLarge);
@@ -602,7 +588,7 @@ impl<Application: ApplicationLayer> Context<Application> {
         &self,
         app: &Application,
         check_allow_incoming_session: impl FnOnce() -> IncomingSessionAction,
-        check_accept_session: impl FnOnce(&Application::PublicKey, &[u8], u64) -> (Option<(bool, Application::Data)>, bool),
+        check_accept_session: impl FnOnce(&Application::PublicKey, &[u8], u64) -> (Option<(bool, Application::SessionData)>, bool),
         mut send_unassociated_reply: impl FnMut(&mut [u8]) -> bool,
         mut send_unassociated_mtu: usize,
         mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
@@ -610,7 +596,7 @@ impl<Application: ApplicationLayer> Context<Application> {
         data_buf: &'a mut [u8],
         mut incoming_physical_packet_buf: Application::IncomingPacketBuffer,
         current_time: i64,
-    ) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::IoError>> {
+    ) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::StorageError>> {
         send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
         let incoming_physical_packet: &mut [u8] = incoming_physical_packet_buf.as_mut();
         let incoming_physical_packet_len = incoming_physical_packet.len();
@@ -902,7 +888,7 @@ impl<Application: ApplicationLayer> Context<Application> {
 
                             sha512.reset();
                             let mut hasher = ShaHasher(sha512);
-                            let mut output = [0u8; NOISE_HASHLEN];
+                            let mut output = [0u8; HASHLEN];
                             hasher.0.update(&response.challenge_counter);
                             remote_address.hash(&mut hasher);
                             hasher.0.update(&self.0.challenge_salt);
@@ -1823,7 +1809,7 @@ fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mu
     counter: u64,
     fragment: &mut [u8],
     current_time: i64,
-) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::IoError>> {
+) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::StorageError>> {
     let kex_lock = session.state_machine_lock.lock().unwrap();
     let state = session.state.read().unwrap();
     let mut c = session.kex_receive_cipher.lock().unwrap();
@@ -2307,7 +2293,7 @@ impl<Application: ApplicationLayer> NoiseXKAliceHandshake<Application> {
             Secret<AES_GCM_KEY_SIZE>,
             Secret<AES_GCM_KEY_SIZE>,
         ),
-        OpenError<Application::IoError>,
+        OpenError<Application::StorageError>,
     > {
         let mut message = [0u8; NoiseXKPattern1::MAX_SIZE];
         let sha512 = &mut Application::Hash::new();
@@ -2433,11 +2419,11 @@ fn process_timer(timer: &AtomicI64, wait_time: i64, current_time: i64) -> Option
 fn encrypt_and_hash<Application: ApplicationLayer>(
     sha512: &mut Application::Hash,
     noise_k: &Secret<AES_GCM_KEY_SIZE>,
-    noise_h: &[u8; NOISE_HASHLEN],
+    noise_h: &[u8; HASHLEN],
     packet_type: u8,
     noise_k_uses: u64,
     message: &mut [u8],
-) -> [u8; NOISE_HASHLEN] {
+) -> [u8; HASHLEN] {
     let auth_start = message.len() - AES_GCM_TAG_SIZE;
     let mut gcm = Application::AeadEnc::new(noise_k.as_ref());
     // Encrypt and add authentication tag.
@@ -2453,11 +2439,11 @@ fn encrypt_and_hash<Application: ApplicationLayer>(
 fn decrypt_and_hash<Application: ApplicationLayer>(
     sha512: &mut Application::Hash,
     noise_k: &Secret<AES_GCM_KEY_SIZE>,
-    noise_h: &[u8; NOISE_HASHLEN],
+    noise_h: &[u8; HASHLEN],
     packet_type: u8,
     noise_k_uses: u64,
     message: &mut [u8],
-) -> (bool, [u8; NOISE_HASHLEN]) {
+) -> (bool, [u8; HASHLEN]) {
     let auth_start = message.len() - AES_GCM_TAG_SIZE;
     let noise_h_c = mix_hash(sha512, noise_h, message);
     let mut gcm = Application::AeadDec::new(noise_k.as_ref());
@@ -2604,7 +2590,7 @@ fn send_with_fragmentation(
 ///
 /// This is also only used for key exchange and control packets. For data packets decryption and
 /// assembly happen in one pass for better performance.
-fn assemble_fragments_into<A: ApplicationLayer>(fragments: &[A::IncomingPacketBuffer], d: &mut [u8]) -> Result<usize, ReceiveError<A::IoError>> {
+fn assemble_fragments_into<A: ApplicationLayer>(fragments: &[A::IncomingPacketBuffer], d: &mut [u8]) -> Result<usize, ReceiveError<A::StorageError>> {
     let mut l = 0;
     for i in 0..fragments.len() {
         let mut ff = fragments[i].as_ref();
@@ -2676,8 +2662,8 @@ impl<Application: ApplicationLayer> SessionKey<Application> {
 }
 
 /// MixHash to update 'h' during negotiation.
-fn mix_hash(hasher: &mut impl Sha512, h: &[u8; NOISE_HASHLEN], m: &[u8]) -> [u8; NOISE_HASHLEN] {
-    let mut output = [0u8; NOISE_HASHLEN];
+fn mix_hash(hasher: &mut impl Sha512, h: &[u8; HASHLEN], m: &[u8]) -> [u8; HASHLEN] {
+    let mut output = [0u8; HASHLEN];
     hasher.reset();
     hasher.update(h);
     hasher.update(m);
@@ -2692,7 +2678,7 @@ fn verify_pow<Application: ApplicationLayer>(hasher: &mut Application::Hash, res
     }
     hasher.reset();
     hasher.update(response);
-    let mut output = [0u8; NOISE_HASHLEN];
+    let mut output = [0u8; HASHLEN];
     hasher.finish(&mut output);
     let n = u32::from_be_bytes(output[..4].try_into().unwrap());
     n.leading_zeros() >= Application::PROOF_OF_WORK_BIT_DIFFICULTY

From 82e3bc647f9dbd559d36858a893333a96bfc564c Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 7 Aug 2023 15:04:02 -0400
Subject: [PATCH 16/50] added sending

---
 rustfmt.toml            |    2 +-
 src/applicationlayer.rs |    2 +-
 src/challenge.rs        |    4 +-
 src/context.rs          |   20 +-
 src/frag_cache.rs       |   31 +-
 src/fragged.rs          |   22 +-
 src/handshake_cache.rs  |   12 +-
 src/lib.rs              |   12 +-
 src/log_event.rs        |    2 +-
 src/proto.rs            |  107 +-
 src/result.rs           |    2 +
 src/symmetric_state.rs  |   32 +-
 src/zeta.rs             | 1085 +++++++--------
 src/zssp.rs             | 2761 ++++++---------------------------------
 14 files changed, 1129 insertions(+), 2965 deletions(-)

diff --git a/rustfmt.toml b/rustfmt.toml
index 3a3929c..9c9fedd 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1,4 +1,4 @@
-max_width = 150
+max_width = 120
 edition = "2021"
 newline_style = "Unix"
 struct_lit_width = 60
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 7f18f60..2dcfc96 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -14,7 +14,7 @@ use crate::crypto::rand_core::{CryptoRng, RngCore};
 use crate::crypto::sha512::{HmacSha512, HashSha512};
 use crate::RatchetState;
 use crate::proto::RATCHET_SIZE;
-use crate::zssp::Session;
+use crate::zeta::Session;
 //use crate::{log_event::LogEvent, Session};
 
 /// A container for a vast majority of the dynamic settings within ZSSP, including all time-based settings.
diff --git a/src/challenge.rs b/src/challenge.rs
index 76e6cc5..c47af7b 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -54,12 +54,12 @@ impl ChallengeContext {
         &self,
         addr: &impl std::hash::Hash,
         response: &[u8; CHALLENGE_SIZE],
-    ) -> Result<bool, [u8; CHALLENGE_SIZE]> {
+    ) -> Result<(), [u8; CHALLENGE_SIZE]> {
         let c = u64::from_be_bytes(response[..COUNTER_SIZE].try_into().unwrap());
         let mut work_buf = [0u8; SHA512_HASH_SIZE];
         if self.antireplay_window.check(c) && secure_eq(&response[COUNTER_SIZE..POW_START], &self.create_mac::<Hash>(c, addr)) && verify_pow::<Hash>(response, &mut work_buf) {
             self.antireplay_window.update(c);
-            Ok(true)
+            Ok(())
         } else {
             let mut challenge = [0u8; CHALLENGE_SIZE];
             let d = self.counter.fetch_add(1, Ordering::Relaxed);
diff --git a/src/context.rs b/src/context.rs
index ba69585..2320365 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -8,6 +8,8 @@ use std::sync::{Arc, Mutex, Weak, RwLock};
 
 use crate::applicationlayer::ApplicationLayer;
 use crate::crypto::aes::{AES_256_KEY_SIZE, AES_GCM_IV_SIZE};
+use crate::frag_cache::UnassociatedFragCache;
+use crate::handshake_cache::UnassociatedHandshakeCache;
 use crate::indexed_heap::IndexedBinaryHeap;
 //use crate::fragmentation::{send_with_fragmentation, DefragBuffer};
 use crate::proto::*;
@@ -46,6 +48,8 @@ pub(crate) struct ContextInner<App: ApplicationLayer> {
     pub(crate) s_secret: App::KeyPair,
     pub(crate) session_queue: Mutex<IndexedBinaryHeap<Weak<Session<App>>, Reverse<i64>>>,
     pub(crate) session_map: SessionMap<App>,
+    unassociated_defrag_cache: Mutex<UnassociatedFragCache<App::IncomingPacketBuffer>>,
+    unassociated_handshake_states: UnassociatedHandshakeCache<App>,
     //pub(crate) b2_map: Mutex<HashMap<NonZeroU32, StateB2<App>>>,
 
     //hello_defrag: Mutex<DefragBuffer>,
@@ -70,19 +74,13 @@ impl<App: ApplicationLayer> Context<App> {
         Self(Arc::new(ContextInner {
             rng: Mutex::new(rng),
             s_secret: static_secret_key,
-            session_map: Mutex::new(HashMap::new()),
-            b2_map: Mutex::new(HashMap::new()),
-            hello_defrag: Mutex::new(DefragBuffer::new(None)),
-            challenge: Mutex::new(challenge),
-            sessions: Mutex::new(HashMap::new()),
+            session_map: RwLock::new(HashMap::new()),
+            challenge,
+            session_queue: Mutex::new(IndexedBinaryHeap::new()),
+            unassociated_defrag_cache: Mutex::new(UnassociatedFragCache::new()),
+            unassociated_handshake_states: UnassociatedHandshakeCache::new(),
         }))
     }
-    /// Enable the ZeroTier Challenge Protocol, to protect this machine from CPU exhaustion DDOS
-    /// attacks.
-    pub fn enable_challenge(&self, enabled: bool) {
-        self.0.challenge.lock().unwrap().enabled = enabled;
-    }
-
     /// Create a new session and send initial packet(s) to other side.
     ///
     /// This will return SendError::DataTooLarge if the combined size of the metadata and the local
diff --git a/src/frag_cache.rs b/src/frag_cache.rs
index 62ddfc0..f0c9c27 100644
--- a/src/frag_cache.rs
+++ b/src/frag_cache.rs
@@ -10,6 +10,7 @@ use std::collections::hash_map::RandomState;
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::mem::MaybeUninit;
 
+use crate::crypto::aes::AES_GCM_IV_SIZE;
 use crate::fragged::Assembled;
 use crate::proto::{MAX_FRAGMENTS, MAX_UNASSOCIATED_FRAGMENTS, MAX_UNASSOCIATED_PACKETS, MAX_UNASSOCIATED_PACKET_SIZE};
 
@@ -17,7 +18,7 @@ struct PacketMetadata {
     key: u64,
     frags_idx: u32,
     fragment_have: u64,
-    fragment_count: u32,
+    fragment_count: u8,
     packet_size: u32,
     creation_time: i64,
 }
@@ -55,24 +56,24 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
     /// Will check that aad is the same for all fragments.
     pub(crate) fn assemble(
         &mut self,
-        nonce: [u8; 10],
+        nonce: &[u8; AES_GCM_IV_SIZE],
         remote_address: impl Hash,
         fragment_size: usize,
         fragment: Fragment,
-        fragment_no: u8,
-        fragment_count: u8,
-        timeout: i64,
+        fragment_no: usize,
+        fragment_count: usize,
+        timeout_interval: i64,
         current_time: i64,
         ret_assembled: &mut Assembled<Fragment>,
     ) {
         debug_assert!(MAX_FRAGMENTS < MAX_UNASSOCIATED_FRAGMENTS);
-        if fragment_no >= fragment_count || (fragment_count as usize) > MAX_FRAGMENTS || fragment_size > MAX_UNASSOCIATED_PACKET_SIZE {
+        if fragment_no >= fragment_count || fragment_count > MAX_FRAGMENTS || fragment_size > MAX_UNASSOCIATED_PACKET_SIZE {
             return;
         }
 
         let mut hasher = self.dos_salt.build_hasher();
         remote_address.hash(&mut hasher);
-        hasher.write(&nonce);
+        hasher.write(nonce);
         let mut key = hasher.finish();
         if key == 0 {
             key = 1;
@@ -98,7 +99,7 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
         } else if self.map[idx0].key == 0 || self.map[idx1].key == 0 {
             if (fragment_count as usize) > self.frags_unused_size {
                 // There are not enough free fragment slots so attempt to expire a bunch of entries.
-                self.check_for_expiry(timeout, current_time);
+                self.check_for_expiry(timeout_interval, current_time);
             }
             if self.map[idx0].key == 0 {
                 idx0
@@ -107,7 +108,7 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
             }
         } else {
             // No room for a new entry so attempt to expire a bunch of entries.
-            self.check_for_expiry(timeout, current_time);
+            self.check_for_expiry(timeout_interval, current_time);
             if self.map[idx0].key == 0 {
                 idx0
             } else if self.map[idx1].key == 0 {
@@ -125,7 +126,7 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
                 entry.key = key;
                 entry.frags_idx = self.frags_first_unused as u32;
                 entry.fragment_have = 0;
-                entry.fragment_count = fragment_count as u32;
+                entry.fragment_count = fragment_count as u8;
                 entry.packet_size = 0;
                 entry.creation_time = current_time;
 
@@ -143,7 +144,7 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
 
         let new_size = entry.packet_size + fragment_size as u32;
         let got = 1u64.wrapping_shl(fragment_no as u32);
-        if got & entry.fragment_have == 0 && fragment_count == entry.fragment_count as u8 && new_size <= MAX_UNASSOCIATED_PACKET_SIZE as u32 {
+        if got & entry.fragment_have == 0 && fragment_count == entry.fragment_count as usize && new_size <= MAX_UNASSOCIATED_PACKET_SIZE as u32 {
             entry.packet_size = new_size;
             entry.fragment_have |= got;
 
@@ -272,9 +273,9 @@ fn test_cache() {
                 if drop != j {
                     let fragment = vec![0, 1, 2, 3, 4, 5, 6, r];
                     // If the timeout is 1 we should be guaranteed to get our packet cached.
-                    let mut nonce = [0; 10];
+                    let mut nonce = [0; 12];
                     nonce[..4].copy_from_slice(&i.to_be_bytes());
-                    cache.assemble(nonce, 0, fragment.len(), fragment, j as u8, fragment_count as u8, 1, time, &mut assembled);
+                    cache.assemble(&nonce, 0, fragment.len(), fragment, j, fragment_count, 1, time, &mut assembled);
                     time += 1;
                 }
             }
@@ -297,9 +298,9 @@ fn test_cache() {
                         let (no, fragment) = packet.swap_remove(xorshift64_random() as usize % packet.len());
 
                         assembled.empty();
-                        let mut nonce = [0; 10];
+                        let mut nonce = [0; 12];
                         nonce[..4].copy_from_slice(&id.to_be_bytes());
-                        cache.assemble(nonce, 0, fragment.len(), fragment, no, fragment_count, 1000, time, &mut assembled);
+                        cache.assemble(&nonce, 0, fragment.len(), fragment, no as usize, fragment_count as usize, 1000, time, &mut assembled);
                         time += 1;
                         in_progress_fragments -= 1;
 
diff --git a/src/fragged.rs b/src/fragged.rs
index 77ee095..145b5d8 100644
--- a/src/fragged.rs
+++ b/src/fragged.rs
@@ -9,7 +9,8 @@
 use std::mem::{needs_drop, zeroed, MaybeUninit};
 use std::ptr::slice_from_raw_parts;
 
-use crate::proto::MAX_FRAGMENTS;
+use crate::crypto::aes::AES_GCM_IV_SIZE;
+use crate::proto::{MAX_FRAGMENTS, NONCE_SIZE_DIFF};
 
 pub(crate) struct Assembled<Fragment>(pub(crate) [MaybeUninit<Fragment>; MAX_FRAGMENTS], pub(crate) usize);
 
@@ -42,9 +43,9 @@ impl<Fragment> Drop for Assembled<Fragment> {
 
 /// Fast packet defragmenter
 pub struct Fragged<Fragment, const MAX_FRAGMENTS: usize> {
-    count: u32,
-    have: u64,
     nonce: [u8; 10],
+    count: u8,
+    have: u64,
     size: usize,
     frags: [MaybeUninit<Fragment>; MAX_FRAGMENTS],
 }
@@ -63,28 +64,29 @@ impl<Fragment, const MAX_FRAGMENTS: usize> Fragged<Fragment, MAX_FRAGMENTS> {
     /// Will check that aad is the same for all fragments.
     pub(crate) fn assemble(
         &mut self,
-        nonce: [u8; 10],
+        nonce: &[u8; AES_GCM_IV_SIZE],
         fragment: Fragment,
-        fragment_no: u8,
-        fragment_count: u8,
+        fragment_no: usize,
+        fragment_count: usize,
         ret_assembled: &mut Assembled<Fragment>,
     ) {
-        if fragment_no < fragment_count && (fragment_count as usize) <= MAX_FRAGMENTS {
+        if fragment_no < fragment_count && fragment_count <= MAX_FRAGMENTS {
+            let nonce = nonce[NONCE_SIZE_DIFF..].try_into().unwrap();
             // If the counter has changed, reset the structure to receive a new packet.
             if nonce != self.nonce {
                 self.drop_in_place();
-                self.count = fragment_count as u32;
+                self.count = fragment_count as u8;
                 self.nonce = nonce;
                 self.size = 0;
             }
 
             let got = 1u64.wrapping_shl(fragment_no as u32);
-            if got & self.have == 0 && self.count as u8 == fragment_count {
+            if got & self.have == 0 && self.count == fragment_count as u8 {
                 self.have |= got;
                 unsafe {
                     self.frags.get_unchecked_mut(fragment_no as usize).write(fragment);
                 }
-                if self.have == 1u64.wrapping_shl(self.count) - 1 {
+                if self.have == 1u64.wrapping_shl(self.count as u32) - 1 {
                     self.have = 0;
                     self.count = 0;
                     self.nonce = [0; 10];
diff --git a/src/handshake_cache.rs b/src/handshake_cache.rs
index 25f219a..8ce3852 100644
--- a/src/handshake_cache.rs
+++ b/src/handshake_cache.rs
@@ -10,7 +10,7 @@ use std::num::NonZeroU32;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock};
 
-use crate::zssp::NoiseXKBobHandshakeState;
+use crate::zeta::StateB2;
 use crate::{proto::MAX_UNASSOCIATED_HANDSHAKE_STATES, ApplicationLayer};
 
 pub(crate) struct UnassociatedHandshakeCache<Application: ApplicationLayer> {
@@ -18,10 +18,10 @@ pub(crate) struct UnassociatedHandshakeCache<Application: ApplicationLayer> {
     cache: RwLock<CacheInner<Application>>,
 }
 /// SoA format
-struct CacheInner<Application: ApplicationLayer> {
+struct CacheInner<App: ApplicationLayer> {
     local_ids: [Option<NonZeroU32>; MAX_UNASSOCIATED_HANDSHAKE_STATES],
     timeouts: [i64; MAX_UNASSOCIATED_HANDSHAKE_STATES],
-    handshakes: [Option<Arc<NoiseXKBobHandshakeState<Application>>>; MAX_UNASSOCIATED_HANDSHAKE_STATES],
+    handshakes: [Option<Arc<StateB2<App>>>; MAX_UNASSOCIATED_HANDSHAKE_STATES],
 }
 
 /// Linear-search cache for capping the memory consumption of handshake data.
@@ -38,7 +38,7 @@ impl<Application: ApplicationLayer> UnassociatedHandshakeCache<Application> {
             }),
         }
     }
-    pub(crate) fn get(&self, local_id: NonZeroU32) -> Option<Arc<NoiseXKBobHandshakeState<Application>>> {
+    pub(crate) fn get(&self, local_id: NonZeroU32) -> Option<Arc<StateB2<Application>>> {
         let cache = self.cache.read().unwrap();
         for (i, id) in cache.local_ids.iter().enumerate() {
             if *id == Some(local_id) {
@@ -47,7 +47,7 @@ impl<Application: ApplicationLayer> UnassociatedHandshakeCache<Application> {
         }
         None
     }
-    pub(crate) fn insert(&self, local_id: NonZeroU32, state: Arc<NoiseXKBobHandshakeState<Application>>, current_time: i64) {
+    pub(crate) fn insert(&self, local_id: NonZeroU32, state: Arc<StateB2<Application>>, current_time: i64) {
         let mut cache = self.cache.write().unwrap();
         let mut idx = 0;
         for i in 0..cache.local_ids.len() {
@@ -59,7 +59,7 @@ impl<Application: ApplicationLayer> UnassociatedHandshakeCache<Application> {
             }
         }
         cache.local_ids[idx] = Some(local_id);
-        cache.timeouts[idx] = current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS);
+        cache.timeouts[idx] = current_time + Application::SETTINGS.fragment_assembly_timeout as i64;
         cache.handshakes[idx] = Some(state);
         self.has_pending.store(true, Ordering::Release);
     }
diff --git a/src/lib.rs b/src/lib.rs
index 16c9ec0..61c0db5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -8,20 +8,20 @@
 pub mod crypto;
 
 mod applicationlayer;
-//mod frag_cache;
-//mod fragged;
-//mod handshake_cache;
+mod fragged;
+mod frag_cache;
+mod handshake_cache;
 mod indexed_heap;
-//mod log_event;
+mod log_event;
 mod proto;
 mod ratchet_state;
 mod symmetric_state;
 mod antireplay;
 mod challenge;
 pub mod result;
-//mod zssp;
+mod zssp;
 mod zeta;
-mod context;
+//mod context;
 
 //pub mod error;
 pub use crate::applicationlayer::ApplicationLayer;
diff --git a/src/log_event.rs b/src/log_event.rs
index be543aa..cf96367 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -7,7 +7,7 @@
  */
 use std::sync::Arc;
 
-use crate::{ApplicationLayer, zssp::Session};
+use crate::{ApplicationLayer, zeta::Session};
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
 pub enum LogEvent<'a, Application: ApplicationLayer> {
diff --git a/src/proto.rs b/src/proto.rs
index 0d466a7..3f11bb1 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -1,8 +1,9 @@
+use crate::crypto::{aes::{AES_GCM_TAG_SIZE, AES_GCM_IV_SIZE}, kyber1024::{KYBER_CIPHERTEXT_SIZE, KYBER_PUBLIC_KEY_SIZE}, p384::P384_PUBLIC_KEY_SIZE, sha512::SHA512_HASH_SIZE};
 
 /* Common constants */
 
-use crate::crypto::{sha512::SHA512_HASH_SIZE, p384::P384_PUBLIC_KEY_SIZE, kyber1024::{KYBER_PUBLIC_KEY_SIZE, KYBER_CIPHERTEXT_SIZE}, aes::AES_GCM_TAG_SIZE};
-
+/// Minimum size of a valid physical ZSSP packet of any type. Anything smaller is discarded.
+pub const MIN_PACKET_SIZE: usize = HEADER_SIZE + AES_GCM_TAG_SIZE;
 /// Minimum physical MTU for ZSSP to function.
 /// If an MTU is passed to ZSSP that is lower than this, it will be ignored and instead this value
 /// will be used.
@@ -44,33 +45,11 @@ pub(crate) const PACKET_NONCE_START: usize = HEADER_SIZE - PACKET_NONCE_SIZE;
 pub(crate) const FRAGMENT_NO_IDX: usize = 4;
 pub(crate) const FRAGMENT_COUNT_IDX: usize = 5;
 
+/// Maximum number of fragments a single packet may be split into. If a packet cannot fit
+/// into this number of fragments it will be dropped.
 pub(crate) const MAX_FRAGMENTS: usize = 48;
 
-/// Maximum window over which session packets may be reordered to be defragmented and
-/// reassembled. Out of order fragments may be dropped in favor of newer fragments.
-/// Increasing this value makes a session consume more significantly more memory.
-pub(crate) const SESSION_MAX_FRAGMENTS_OOO: usize = 32;
-/// The maximum number of unassociated packets that a receive context will cache.
-/// Additional packets will either be dropped or cause a different packet to be dropped
-/// from the cache.
-/// Larger values consume more memory but provide better reliability and DDOS resistance.
-pub(crate) const MAX_UNASSOCIATED_PACKETS: usize = 32;
-/// The maximum number of fragments of unassociated packets that a receive context will
-/// cache.
-/// All unassociated fragments share the same buffer, when it fills up additional
-/// fragments will be dropped or cause other fragments to be dropped from the cache.
-/// Larger values consume more memory but provide better reliability and DDOS resistance.
-pub(crate) const MAX_UNASSOCIATED_FRAGMENTS: usize = 32 * 32;
-/// The maximum number of `NoiseXKBobHandshakeState` that a receive context will cache.
-/// These are extremely large and since Alice has not been authenticated we put a hard
-/// limit to how many we cache.
-/// Larger values consume more memory but provide better reliability and DDOS resistance.
-pub(crate) const MAX_UNASSOCIATED_HANDSHAKE_STATES: usize = 32;
-
-/// The maximum size a packet that is not associated to a session may be.
-/// Excludes the size of headers for fragmentation.
-pub(crate) const MAX_UNASSOCIATED_PACKET_SIZE: usize = HANDSHAKE_HELLO_MAX_SIZE - HEADER_SIZE;
-
+pub(crate) const NONCE_SIZE_DIFF: usize = AES_GCM_IV_SIZE - PACKET_NONCE_SIZE;
 
 /* Key exchange constants */
 /*
@@ -93,9 +72,11 @@ pub(crate) const HASHLEN: usize = SHA512_HASH_SIZE;
 /// The size in bytes of both a ratchet key and a ratchet fingerprint.
 pub const RATCHET_SIZE: usize = 32;
 
-pub(crate) const PROTOCOL_NAME_NOISE_XK: [u8; HASHLEN] = *b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
-pub(crate) const PROTOCOL_NAME_NOISE_KK: [u8; HASHLEN] =
-    *b"Noise_KKpsk0_P384_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+/// Initial value of 'h'.
+pub(crate) const PROTOCOL_NAME_NOISE_XK: &[u8; HASHLEN] = b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+/// Initial value of 'ck' for rekeying.
+pub(crate) const PROTOCOL_NAME_NOISE_KK: &[u8; HASHLEN] =
+    b"Noise_KKpsk0_P384_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 
 pub(crate) const LABEL_OTP_TO_RATCHET: &[u8; 19] = b"ZSSP_OTP_TO_RATCHET";
 pub(crate) const LABEL_KBKDF_CHAIN: &[u8; 4] = b"ZSSP";
@@ -104,9 +85,21 @@ pub(crate) const LABEL_HEADER_KEY: &[u8; 4] = b"ASKH";
 pub(crate) const LABEL_KEX_KEY: &[u8; 4] = b"ASKK";
 
 pub(crate) const INIT_COUNTER: u64 = 0;
-pub(crate) const EXPIRE_AFTER_USES: u64 = 4294967295;
+pub(crate) const EXPIRE_AFTER_USES: u64 = 1 << 32 - 1;
+/// Determines the number of counters a session will remember. If a counter arrives over
+/// this amount out of order relative to other received counters, it is likely to be
+/// rejected on the basis that the session can't remember if this counter was replayed.
+/// Increasing this value makes a session consume more memory.
 pub(crate) const COUNTER_WINDOW_MAX_OOO: usize = 64;
+/// Maximum number of counter steps that the counter is allowed to skip ahead.
+/// This cannot be changed away from 2^24 without changing the header nonce handling code.
 pub(crate) const COUNTER_WINDOW_MAX_SKIP_AHEAD: u64 = 1 << 24;
+/// Similar to `COUNTER_WINDOW_MAX_OOO`, except this governs the receive context challenge
+/// counter rather than the session counter.
+/// When Bob issues a challenge to Alice to mitigate DDOS, Bob will only accept Alice's
+/// response once, and then its attached counter is added to the window.
+pub(crate) const CHALLENGE_COUNTER_WINDOW_MAX_OOO: usize = 32;
+pub(crate) const THREAD_SAFE_COUNTER_HARD_EXPIRE: u64 = u64::MAX - 1<<16;
 
 /* Packet constants */
 
@@ -122,20 +115,64 @@ pub(crate) const PACKET_TYPE_DATA: u8 = 8;
 pub(crate) const PACKET_TYPE_CHALLENGE: u8 = 9;
 pub(crate) const PACKET_TYPE_USES_COUNTER_RANGE: std::ops::Range<u8> = 3..9;
 
-pub(crate) const MAX_HANDSHAKE_SIZE: usize = MAX_FRAGMENTS * MIN_TRANSPORT_MTU;
-
 pub(crate) const HANDSHAKE_HELLO_MIN_SIZE: usize = KID_SIZE + P384_PUBLIC_KEY_SIZE + KYBER_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
 pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RATCHET_SIZE;
 
+pub(crate) const HANDSHAKE_HELLO_CHALLENGE_MIN_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + CHALLENGE_SIZE;
+pub(crate) const HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE: usize = HANDSHAKE_HELLO_MAX_SIZE + CHALLENGE_SIZE;
+
+pub(crate) const HEADERED_HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE: usize = HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE + HEADER_SIZE;
+
 pub(crate) const HANDSHAKE_RESPONSE_SIZE: usize = P384_PUBLIC_KEY_SIZE + KYBER_CIPHERTEXT_SIZE + AES_GCM_TAG_SIZE + KID_SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const HEADERED_HANDSHAKE_RESPONSE_SIZE: usize = HANDSHAKE_RESPONSE_SIZE + HEADER_SIZE;
 
 pub(crate) const HANDSHAKE_COMPLETION_MIN_SIZE: usize = P384_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + 0 + AES_GCM_TAG_SIZE;
-pub(crate) const HANDSHAKE_COMPLETION_MAX_SIZE: usize = MAX_HANDSHAKE_SIZE;
+pub(crate) const HANDSHAKE_COMPLETION_MAX_SIZE: usize = HANDSHAKE_COMPLETION_MIN_SIZE + IDENTITY_MAX_SIZE;
+
+pub(crate) const HEADERED_HANDSHAKE_COMPLETION_MAX_SIZE: usize = HANDSHAKE_COMPLETION_MAX_SIZE + HEADER_SIZE;
 
 pub(crate) const KEY_CONFIRMATION_SIZE: usize = AES_GCM_TAG_SIZE;
+pub(crate) const HEADERED_KEY_CONFIRMATION_SIZE: usize = KEY_CONFIRMATION_SIZE + HEADER_SIZE;
+
 pub(crate) const ACKNOWLEDGEMENT_SIZE: usize = AES_GCM_TAG_SIZE;
+pub(crate) const HEADERED_ACKNOWLEDGEMENT_SIZE: usize = ACKNOWLEDGEMENT_SIZE + HEADER_SIZE;
+
 pub(crate) const SESSION_REJECTED_SIZE: usize = AES_GCM_TAG_SIZE;
+pub(crate) const HEADERED_SESSION_REJECTED_SIZE: usize = SESSION_REJECTED_SIZE + HEADER_SIZE;
 
 pub(crate) const REKEY_SIZE: usize = P384_PUBLIC_KEY_SIZE + KID_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const HEADERED_REKEY_SIZE: usize = P384_PUBLIC_KEY_SIZE + KID_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
 
-pub(crate) const MAX_IDENTITY_SIZE: usize = MAX_HANDSHAKE_SIZE - HANDSHAKE_COMPLETION_MIN_SIZE;
+/// The application has the ability to attach a data payload to Alice's handshake.
+/// It will be the first payload Bob receives from Alice.
+/// The application also must attach a static public identity to their handshake.
+/// The combined size of both in bytes must be at most this value.
+///
+/// If not ZSSP will return `OpenError::DataTooLarge` and refuse to create a session object.
+pub const IDENTITY_MAX_SIZE: usize = 4096;
+
+/* DOS mitigation constants */
+
+/// The maximum number of `NoiseXKBobHandshakeState` that a receive context will cache.
+/// These are extremely large and since Alice has not been authenticated we put a hard
+/// limit to how many we cache.
+/// Larger values consume more memory but provide better reliability and DDOS resistance.
+pub(crate) const MAX_UNASSOCIATED_HANDSHAKE_STATES: usize = 32;
+
+/// The maximum number of unassociated packets that a receive context will cache.
+/// Additional packets will either be dropped or cause a different packet to be dropped
+/// from the cache.
+/// Larger values consume more memory but provide better reliability and DDOS resistance.
+pub(crate) const MAX_UNASSOCIATED_PACKETS: usize = 32;
+/// The maximum number of fragments of unassociated packets that a receive context will
+/// cache.
+/// All unassociated fragments share the same buffer, when it fills up additional
+/// fragments will be dropped or cause other fragments to be dropped from the cache.
+/// Larger values consume more memory but provide better reliability and DDOS resistance.
+pub(crate) const MAX_UNASSOCIATED_FRAGMENTS: usize = 32 * 32;
+
+/// The maximum size a packet that is not associated to a session may be.
+/// Excludes the size of headers for fragmentation.
+pub(crate) const MAX_UNASSOCIATED_PACKET_SIZE: usize = HANDSHAKE_HELLO_MAX_SIZE;
+
+pub(crate) const SESSION_MAX_FRAGMENTS_OOO: usize = 64;
diff --git a/src/result.rs b/src/result.rs
index d542227..4710492 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -10,6 +10,8 @@ pub enum OpenError<IoError> {
     /// An invalid parameter was supplied to the function.
     InvalidPublicKey,
 
+    IdentityTooLarge,
+
     RatchetIoError(IoError),
 }
 
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index a2caf2b..f2e2a22 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -80,11 +80,11 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
 
     /// Corresponds to Noise `Initialize` on a SymmetricState.
-    pub fn initialize(h: [u8; HASHLEN]) -> Self {
+    pub fn initialize(h: &[u8; HASHLEN]) -> Self {
         Self {
             k: Zeroizing::default(),
-            ck: Zeroizing::new(h),
-            h,
+            ck: Zeroizing::new(*h),
+            h: *h,
             _app: PhantomData,
         }
     }
@@ -98,6 +98,14 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         *self.ck = *next_ck;
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
+    /// Corresponds to Noise `MixKey`.
+    pub fn mix_key_no_init(&mut self, hmac: &mut App::HmacHash, input_key_material: &[u8]) {
+        let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
+
+        self.kbkdf(hmac, input_key_material, LABEL_KBKDF_CHAIN, 2, &mut next_ck, None, None);
+
+        *self.ck = *next_ck;
+    }
     /// Corresponds to Noise `MixHash`.
     pub fn mix_hash(&mut self, hash: &mut App::Hash, data: &[u8]) {
         hash.update(&self.h);
@@ -124,6 +132,24 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.mix_hash(hash, &temp_h);
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
+    /// Corresponds to Noise `MixKeyAndHash`.
+    pub fn mix_key_and_hash_no_init(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, input_key_material: &[u8]) {
+        let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
+        let mut temp_h = [0u8; HASHLEN];
+
+        self.kbkdf(
+            hmac,
+            input_key_material,
+            LABEL_KBKDF_CHAIN,
+            3,
+            &mut next_ck,
+            Some(&mut temp_h),
+            None,
+        );
+
+        *self.ck = *next_ck;
+        self.mix_hash(hash, &temp_h);
+    }
     /// Corresponds to Noise `EncryptAndHash`.
     #[must_use]
     pub fn encrypt_and_hash_in_place<const CAP: usize>(&mut self, hash: &mut App::Hash, iv: [u8; AES_GCM_IV_SIZE], data: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE] {
diff --git a/src/zeta.rs b/src/zeta.rs
index 159df8b..9203426 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -4,7 +4,7 @@ use std::cmp::Reverse;
 use std::collections::HashMap;
 use std::num::NonZeroU32;
 use std::ops::{Deref, DerefMut};
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::atomic::{AtomicU64, Ordering, AtomicBool};
 use std::sync::{Arc, Mutex, Weak, RwLock};
 use zeroize::Zeroizing;
 
@@ -12,19 +12,18 @@ use crate::antireplay::Window;
 use crate::applicationlayer::ApplicationLayer;
 use crate::applicationlayer::RatchetUpdate;
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
-use crate::context::ContextInner;
+use crate::zssp::{ContextInner, log};
 //use crate::context::{log, ContextInner, SessionMap};
-use crate::crypto::aes::{HighThroughputAesGcmPool, LowThroughputAesGcm, AES_GCM_IV_SIZE, AES_256_KEY_SIZE, AES_GCM_TAG_SIZE};
+use crate::crypto::aes::*;
 use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
 use crate::crypto::sha512::{HashSha512, HmacSha512};
 use crate::crypto::kyber1024::{Kyber1024PrivateKey, KYBER_PUBLIC_KEY_SIZE, KYBER_CIPHERTEXT_SIZE, KYBER_PLAINTEXT_SIZE};
 use crate::indexed_heap::BinaryHeapIndex;
-//use crate::indexed_heap::BinaryHeapIndex;
-//use crate::fragmentation::DefragBuffer;
 use crate::proto::*;
 use crate::ratchet_state::RatchetState;
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
 use crate::symmetric_state::SymmetricState;
+use crate::fragged::Fragged;
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
 
@@ -50,12 +49,23 @@ pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
     let c_start = n.len() - 8;
     (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
 }
-fn create_ratchet_state<App: ApplicationLayer>(hmac: &mut App::HmacHash, noise: &mut SymmetricState<App>, pre_chain_len: u64) -> RatchetState {
+fn create_ratchet_state<App: ApplicationLayer>(hmac: &mut App::HmacHash, noise: &SymmetricState<App>, pre_chain_len: u64) -> RatchetState {
     let mut rk = Zeroizing::new([0u8; HASHLEN]);
     let mut rf = Zeroizing::new([0u8; HASHLEN]);
     noise.get_ask(hmac, LABEL_RATCHET_STATE, &mut rk, &mut rf);
     RatchetState::new(Zeroizing::new(rk[..RATCHET_SIZE].try_into().unwrap()), Zeroizing::new(rf[..RATCHET_SIZE].try_into().unwrap()), pre_chain_len + 1)
 }
+fn get_counter<App: ApplicationLayer>(session: &Session<App>, state: &MutableState<App>) -> Option<(u64, bool)> {
+    if session.session_has_expired.load(Ordering::Relaxed) {
+        None
+    } else {
+        let c = session.send_counter.fetch_add(1, Ordering::Relaxed);
+        if c > THREAD_SAFE_COUNTER_HARD_EXPIRE {
+            session.session_has_expired.store(true, Ordering::SeqCst)
+        }
+        Some((c, c > state.key_creation_counter + App::SETTINGS.rekey_after_key_uses))
+    }
+}
 
 /// Corresponds to the Zeta State Machine found in Section 4.1.
 pub(crate) struct Session<App: ApplicationLayer> {
@@ -66,16 +76,19 @@ pub(crate) struct Session<App: ApplicationLayer> {
     pub was_bob: bool,
     queue_idx: BinaryHeapIndex,
 
-    s_remote: App::PublicKey,
+    pub(crate) s_remote: App::PublicKey,
     send_counter: AtomicU64,
+    session_has_expired: AtomicBool,
 
     pub window: Window<COUNTER_WINDOW_MAX_OOO, COUNTER_WINDOW_MAX_SKIP_AHEAD>,
-    //defrag: [Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
+    pub(crate) defrag: [Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
+    pub(crate) hk_send: App::PrpEnc,
+    pub(crate) hk_recv: App::PrpDec,
 
     state_machine_lock: Mutex<()>,
-    state: RwLock<MutableState<App>>,
+    pub(crate) state: RwLock<MutableState<App>>,
 
-    /// Pre-computed rekeying values.
+    /// Pre-computed rekeying value.
     noise_kk_ss: Zeroizing<[u8; P384_ECDH_SHARED_SECRET_SIZE]>,
 }
 pub(crate) struct MutableState<App: ApplicationLayer> {
@@ -85,7 +98,6 @@ pub(crate) struct MutableState<App: ApplicationLayer> {
     key_creation_counter: u64,
     key_index: bool,
     keys: [DuplexKey<App>; 2],
-    pub hk_send: Zeroizing<[u8; AES_256_KEY_SIZE]>,
 
     resend_timer: i64,
     timeout_timer: i64,
@@ -98,23 +110,40 @@ pub(crate) struct StateB2<App: ApplicationLayer> {
     kid_send: NonZeroU32,
     pub kid_recv: NonZeroU32,
     pub hk_send: Zeroizing<[u8; AES_256_KEY_SIZE]>,
+    pub hk_recv: Zeroizing<[u8; AES_256_KEY_SIZE]>,
     e_secret: App::KeyPair,
     noise: SymmetricState<App>,
-    //pub defrag: DefragBuffer,
+    pub defrag: Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>,
 }
 
-#[derive(Default)]
 pub(crate) struct DuplexKey<App: ApplicationLayer> {
     send: Keys,
     recv: Keys,
     nk: Option<App::AeadPool>,
 }
+impl<App: ApplicationLayer> Default for DuplexKey<App> {
+    fn default() -> Self {
+        Self { send: Default::default(), recv: Default::default(), nk: None }
+    }
+}
+impl<App: ApplicationLayer> DuplexKey<App> {
+    fn replace_nk(&mut self, nk_send: &[u8; HASHLEN], nk_recv: &[u8; HASHLEN]) {
+        self.nk = Some(App::AeadPool::new((&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap(), (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()))
+    }
+}
 
 #[derive(Default)]
 pub(crate) struct Keys {
     kek: Option<Zeroizing<[u8; AES_256_KEY_SIZE]>>,
     kid: Option<NonZeroU32>,
 }
+impl Keys {
+    fn replace_kek(&mut self, kek: &[u8; HASHLEN]) {
+        // We want to give rust the best chance of implementing this in a way that does
+        // not leak the key on the stack.
+        self.kek.get_or_insert(Zeroizing::new([0u8; AES_256_KEY_SIZE])).copy_from_slice(&kek[..AES_256_KEY_SIZE]);
+    }
+}
 
 /// Corresponds to the tuple of values the Transition Algorithms send to the remote peer in Section 4.3.
 //#[derive(Clone)]
@@ -126,31 +155,29 @@ pub(crate) struct StateA1<App: ApplicationLayer> {
     noise: SymmetricState<App>,
     e_secret: App::KeyPair,
     e1_secret: App::Kem,
-    identity: ArrayVec<u8, MAX_IDENTITY_SIZE>,
-    kid_send: u32,
-    nonce: [u8; AES_GCM_IV_SIZE],
-    packet: ArrayVec<u8, HANDSHAKE_HELLO_MAX_SIZE>,
+    identity: ArrayVec<u8, IDENTITY_MAX_SIZE>,
+    x1: ArrayVec<u8, HEADERED_HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE>,
 }
 
 /// Corresponds to the ZKE Automata found in Section 4.1 - Definition 2.
 pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
     Null,
-    A1(StateA1<App>),
+    A1(Box<StateA1<App>>),
     A3 {
-        identity: ArrayVec<u8, MAX_IDENTITY_SIZE>,
+        identity: ArrayVec<u8, IDENTITY_MAX_SIZE>,
         kid_send: u32,
         nonce: [u8; AES_GCM_IV_SIZE],
-        packet: ArrayVec<u8, HANDSHAKE_COMPLETION_MAX_SIZE>,
+        x3: ArrayVec<u8, HEADERED_HANDSHAKE_COMPLETION_MAX_SIZE>,
     },
     S1,
     S2,
     R1 {
         noise: SymmetricState<App>,
         e_secret: App::KeyPair,
-        k1: Vec<u8>,
+        k1: ArrayVec<u8, REKEY_SIZE>,
     },
     R2 {
-        k2: Vec<u8>,
+        k2: ArrayVec<u8, REKEY_SIZE>,
     },
 }
 
@@ -205,6 +232,11 @@ impl<App: ApplicationLayer> MutableState<App> {
     }
 }
 
+fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_IV_SIZE]) {
+    packet[..KID_SIZE].copy_from_slice(&kid_send.to_be_bytes());
+    packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
+}
+
 fn create_a1_state<App: ApplicationLayer>(
     hash: &mut App::Hash, hmac: &mut App::HmacHash, rng: &Mutex<App::Rng>,
     s_remote: &App::PublicKey,
@@ -212,12 +244,13 @@ fn create_a1_state<App: ApplicationLayer>(
     ratchet_state1: &RatchetState,
     ratchet_state2: Option<&RatchetState>,
     identity: &[u8],
-) -> Option<StateA1<App>> {
+) -> Option<Box<StateA1<App>>> {
     //    <- s
     //    ...
     //    -> e, es, e1
     let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_XK);
-    let mut x1 = ArrayVec::<u8, HANDSHAKE_HELLO_MAX_SIZE>::new();
+    let mut x1 = ArrayVec::<u8, HEADERED_HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE>::new();
+    x1.extend([0u8; HEADER_SIZE]);
     // Noise process prologue.
     let kid = kid_recv.get().to_be_bytes();
     x1.extend(kid);
@@ -245,16 +278,18 @@ fn create_a1_state<App: ApplicationLayer>(
 
     let c = u64::from_be_bytes(x1[x1.len() - 8..].try_into().unwrap());
 
+    // Process challenge
     x1.extend(gen_null_response(rng.lock().unwrap().deref_mut()));
-    Some(StateA1 {
+
+    set_header(&mut x1, 0, &to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, c));
+
+    Some(Box::new(StateA1 {
         noise,
         e_secret,
         e1_secret,
         identity: identity.try_into().unwrap(),
-        kid_send: 0,
-        nonce: to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, c),
-        packet: x1,
-    })
+        x1,
+    }))
 }
 /// Corresponds to Transition Algorithm 1 found in Section 4.3.
 pub(crate) fn trans_to_a1<App: ApplicationLayer>(
@@ -263,7 +298,7 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     s_remote: App::PublicKey,
     session_data: App::SessionData,
     identity: &[u8],
-    //send: impl FnOnce(&Packet),
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
     let (ratchet_state1, ratchet_state2) = app
         .restore_by_identity(&s_remote, &session_data)
@@ -276,12 +311,18 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     let hash = &mut App::Hash::new();
     let hmac = &mut App::HmacHash::new();
     let a1 = create_a1_state(hash, hmac, &ctx.rng, &s_remote, kid_recv, &ratchet_state1, ratchet_state2.as_ref(), identity).ok_or(OpenError::InvalidPublicKey)?;
-    let packet = a1.packet.clone();
+
+    let mut noise_kk_ss = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
+    if !ctx.s_secret.agree(&s_remote, &mut noise_kk_ss) {
+        return Err(OpenError::InvalidPublicKey)
+    }
 
     let mut hk_recv = Zeroizing::new([0u8; HASHLEN]);
     let mut hk_send = Zeroizing::new([0u8; HASHLEN]);
     a1.noise.get_ask(hmac, LABEL_HEADER_KEY, &mut hk_recv, &mut hk_send);
 
+    let mut x1 = a1.x1.clone();
+
     let current_time = app.time();
     let queue_idx = session_queue.reserve_index();
     let mut session = Arc::new(Session {
@@ -290,20 +331,23 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         queue_idx,
         s_remote,
         send_counter: AtomicU64::new(0),
+        session_has_expired: AtomicBool::new(false),
         window: Window::new(),
         state_machine_lock: Mutex::new(()),
         state: RwLock::new(MutableState {
-            ratchet_state1,
-            ratchet_state2,
+            ratchet_state1: ratchet_state1.clone(),
+            ratchet_state2: ratchet_state2.clone(),
             key_creation_counter: 0,
             key_index: true,
             keys: [DuplexKey::default(), DuplexKey::default()],
-            hk_send: Zeroizing::new(hk_send[..AES_256_KEY_SIZE].try_into().unwrap()),
             resend_timer: current_time + App::SETTINGS.resend_time as i64,
             timeout_timer: current_time + App::SETTINGS.initial_offer_timeout as i64,
             beta: ZetaAutomata::A1(a1),
         }),
-        noise_kk_ss: Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]),
+        noise_kk_ss: noise_kk_ss.clone(),
+        defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
+        hk_send: App::PrpEnc::new((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap()),
+        hk_recv: App::PrpDec::new((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()),
     });
     let mut state = session.state.write().unwrap();
     state.key_mut(true).recv.kid = Some(kid_recv);
@@ -315,37 +359,46 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         Reverse(state.next_timer()),
     );
 
-    //send(&packet);
+    send(&mut x1, None);
 
     Ok(session)
 }
 /// Corresponds to Algorithm 13 found in Section 5.
-//pub(crate) fn respond_to_challenge<App: ApplicationLayer>(zeta: &mut Zeta<App>, rng: &Mutex<App::Rng>, challenge: &[u8; CHALLENGE_SIZE]) {
-//    if let ZetaAutomata::A1(StateA1 { packet: Packet(_, _, x1), .. }) = &mut zeta.beta {
-//        let response_start = x1.len() - CHALLENGE_SIZE;
-//        respond_to_challenge_in_place::<App::Rng, App::Hash>(
-//            rng.lock().unwrap().deref_mut(),
-//            challenge,
-//            (&mut x1[response_start..]).try_into().unwrap(),
-//        );
-//    }
-//}
+pub(crate) fn respond_to_challenge<App: ApplicationLayer>(session: &mut Session<App>, rng: &Mutex<App::Rng>, challenge: &[u8; CHALLENGE_SIZE]) {
+    let mut state = session.state.write().unwrap();
+    if let ZetaAutomata::A1(a1) = &mut state.beta {
+        let response_start = a1.x1.len() - CHALLENGE_SIZE;
+        respond_to_challenge_in_place::<App::Rng, App::Hash>(
+            rng.lock().unwrap().deref_mut(),
+            challenge,
+            (&mut a1.x1[response_start..]).try_into().unwrap(),
+        );
+    }
+}
 /// Corresponds to Transition Algorithm 2 found in Section 4.3.
 pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     app: &App,
     ctx: &ContextInner<App>,
+    remote_address: &impl std::hash::Hash,
     n: [u8; AES_GCM_IV_SIZE],
-    mut x1: Vec<u8>,
-    //send: impl FnOnce(&Packet, &[u8; AES_256_KEY_SIZE]),
+    x1: &mut [u8],
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    <- s
     //    ...
     //    -> e, es, e1
     //    <- e, ee, ekem1, psk
-    if !(HANDSHAKE_HELLO_MIN_SIZE..=HANDSHAKE_HELLO_MAX_SIZE).contains(&x1.len()) {
+    if !(HANDSHAKE_HELLO_CHALLENGE_MIN_SIZE..=HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE).contains(&x1.len()) {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
+
+    if let Err(challenge) = ctx.challenge.process_hello::<App::Hash>(remote_address, (&x1[x1.len() - CHALLENGE_SIZE..]).try_into().unwrap()) {
+        ///
+
+        return Err(byzantine_fault!(FailedAuth, false));
+    }
+
     if &n[AES_GCM_IV_SIZE - 8..] != &x1[x1.len() - 8..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
@@ -405,7 +458,8 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     let mut hk_send = Zeroizing::new([0u8; HASHLEN]);
     noise.get_ask(hmac, LABEL_HEADER_KEY, &mut hk_recv, &mut hk_send);
 
-    let mut x2 = ArrayVec::new();
+    let mut x2 = ArrayVec::<u8, HEADERED_HANDSHAKE_RESPONSE_SIZE>::new();
+    x2.extend([0u8; HEADER_SIZE]);
     // Process message pattern 2 e token.
     let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut x2);
     // Process message pattern 2 ee token.
@@ -435,21 +489,24 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     c[7] = x2[i - 1];
     let c = u64::from_be_bytes(c);
 
-    ///
-    //ctx.b2_map.lock().unwrap().insert(
-    //    kid_recv,
-    //    StateB2 {
-    //        ratchet_state,
-    //        kid_send,
-    //        kid_recv,
-    //        hk_send: hk_send.clone(),
-    //        e_secret,
-    //        noise,
-    //        defrag: DefragBuffer::new(Some(hk_recv)),
-    //    },
-    //);
+    set_header(&mut x2, kid_send.get(), &to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, c));
 
-    //send(&Packet(kid_send.get(), to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, c), x2), &hk_send);
+    ctx.unassociated_handshake_states.insert(
+        kid_recv,
+        Arc::new(StateB2 {
+            ratchet_state,
+            kid_send,
+            kid_recv,
+            hk_send: Zeroizing::new(hk_send[..AES_256_KEY_SIZE].try_into().unwrap()),
+            hk_recv: Zeroizing::new(hk_recv[..AES_256_KEY_SIZE].try_into().unwrap()),
+            e_secret,
+            noise,
+            defrag: Mutex::new(Fragged::new()),
+        }),
+        app.time()
+    );
+
+    send(&mut x2, Some(&App::PrpEnc::new(&hk_send[..AES_256_KEY_SIZE].try_into().unwrap())));
     Ok(())
 }
 /// Corresponds to Transition Algorithm 3 found in Section 4.3.
@@ -460,7 +517,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     kid: NonZeroU32,
     n: [u8; AES_GCM_IV_SIZE],
     mut x2: &[u8],
-    //send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    <- e, ee, ekem1, psk
@@ -481,14 +538,14 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_IV_SIZE - 3..] != &x2[x2.len() - 3..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let result = (|| {
-        if let ZetaAutomata::A1(StateA1 { noise, e_secret, e1_secret, identity, .. }) = &state.beta {
-            let mut noise = noise.clone();
+    let mut result = (|| {
+        if let ZetaAutomata::A1(a1) = &state.beta {
+            let mut noise = a1.noise.clone();
             let mut i = 0;
             // Process message pattern 2 e token.
             let e_remote = noise.read_e(hash, hmac, &mut i, &x2).ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 ee token.
-            noise.mix_dh(hmac, e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            noise.mix_dh(hmac, &a1.e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 ekem1 token.
             let j = i + KYBER_CIPHERTEXT_SIZE;
             let k = j + AES_GCM_TAG_SIZE;
@@ -497,7 +554,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 return Err(byzantine_fault!(FailedAuth, true));
             }
             let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
-            if !e1_secret.decapsulate((&x2[i..j]).try_into().unwrap(), &mut ekem1_secret) {
+            if !a1.e1_secret.decapsulate((&x2[i..j]).try_into().unwrap(), &mut ekem1_secret) {
                 return Err(byzantine_fault!(FailedAuth, true));
             }
             noise.mix_key(hmac, ekem1_secret.as_ref());
@@ -514,7 +571,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             let payload: [u8; KID_SIZE] = x2[i..j].try_into().unwrap();
             let tag = x2[j..k].try_into().unwrap();
             // Check for which ratchet key Bob wants to use.
-            let test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState<App>)> {
+            let mut test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState<App>)> {
                 let mut noise = noise.clone();
                 let mut payload = payload.clone();
                 // Process message pattern 2 psk token.
@@ -547,8 +604,9 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             }
 
             let (kid_send, mut noise) = result.ok_or(byzantine_fault!(FailedAuth, true))?;
-            let mut x3 = ArrayVec::new();
 
+            let mut x3 = ArrayVec::<u8, HEADERED_HANDSHAKE_COMPLETION_MAX_SIZE>::new();
+            x3.extend([0u8; HEADER_SIZE]);
             // Process message pattern 3 s token.
             let i = x3.len();
             x3.extend(ctx.s_secret.public_key_bytes());
@@ -557,7 +615,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 3 payload.
             let i = x3.len();
-            x3.try_extend_from_slice(identity).unwrap();
+            x3.try_extend_from_slice(&a1.identity).unwrap();
             x3.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), &mut x3[i..]));
 
             let new_ratchet_state = create_ratchet_state(hmac, &mut noise, chain_len);
@@ -582,10 +640,10 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 return Err(ReceiveError::RatchetIoError(e));
             }
 
-            let kek_recv = Zeroizing::new([0u8; HASHLEN]);
-            let kek_send = Zeroizing::new([0u8; HASHLEN]);
-            let nk_recv = Zeroizing::new([0u8; HASHLEN]);
-            let nk_send = Zeroizing::new([0u8; HASHLEN]);
+            let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
+            let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
+            let mut nk_recv = Zeroizing::new([0u8; HASHLEN]);
+            let mut nk_send = Zeroizing::new([0u8; HASHLEN]);
             noise.get_ask(hmac, LABEL_KEX_KEY, &mut kek_recv, &mut kek_send);
             noise.split(hmac, &mut nk_recv, &mut nk_send);
             let nonce = to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0);
@@ -595,37 +653,37 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             let mut state = session.state.write().unwrap();
 
             state.key_mut(true).send.kid = Some(kid_send);
-            state.key_mut(true).send.kek = Some(Zeroizing::new(kek_send[..AES_256_KEY_SIZE].try_into().unwrap()));
-            state.key_mut(true).recv.kek = Some(Zeroizing::new(kek_recv[..AES_256_KEY_SIZE].try_into().unwrap()));
-            state.key_mut(true).nk = Some(App::AeadPool::new((&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap(), (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()));
+            state.key_mut(true).send.replace_kek(&kek_send);
+            state.key_mut(true).recv.replace_kek(&kek_recv);
+            state.key_mut(true).replace_nk(&nk_send, &nk_recv);
             state.ratchet_state2 = Some(state.ratchet_state1.clone());
             state.ratchet_state1 = new_ratchet_state.clone();
             let current_time = app.time();
             state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
             state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
             state.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
-            state.beta = ZetaAutomata::A3 { identity: identity.clone(), packet: x3, kid_send: kid_send.get(), nonce };
+            state.beta = ZetaAutomata::A3 { identity: a1.identity.clone(), x3: x3.clone(), kid_send: kid_send.get(), nonce };
 
-            Ok(())
+            Ok(x3)
         } else {
             Err(byzantine_fault!(FailedAuth, true))
         }
     })();
-    match &result {
-        Err(ReceiveError::ByzantineFault { .. }) => timeout_trans(state, session, app, ctx, app.time(), send),
-        Ok(packet) => send(packet, Some(&state.hk_send)),
+    match &mut result {
+        Err(ReceiveError::ByzantineFault { .. }) => process_timers(app, ctx, session, app.time(), true, false, send),
+        Ok(mut packet) => send(&mut packet, Some(&session.hk_send)),
         _ => {}
     }
     result.map(|_| ())
 }
 /// Corresponds to Transition Algorithm 4 found in Section 4.3.
 pub(crate) fn received_x3_trans<App: ApplicationLayer>(
-    zeta: StateB2<App>,
     app: &App,
     ctx: &Arc<ContextInner<App>>,
+    zeta: StateB2<App>,
     kid: NonZeroU32,
     mut x3: Vec<u8>,
-    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<Arc<Session<App>>, ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    -> s, se
@@ -635,6 +693,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     if kid != zeta.kid_recv {
         return Err(byzantine_fault!(UnknownLocalKeyId, true));
     }
+    let mut hash = &mut App::Hash::new();
+    let mut hmac = &mut App::HmacHash::new();
 
     let mut noise = zeta.noise.clone();
     let mut i = 0;
@@ -642,39 +702,42 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     let j = i + P384_PUBLIC_KEY_SIZE;
     let k = j + AES_GCM_TAG_SIZE;
     let tag = x3[j..k].try_into().unwrap();
-    if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..j], tag) {
+    if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..j], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let s_remote = App::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
     i = k;
     // Process message pattern 3 se token.
-    noise.mix_dh(&zeta.e_secret, &s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    noise.mix_dh(hmac, &zeta.e_secret, &s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 3 payload.
     let k = x3.len();
     let j = k - AES_GCM_TAG_SIZE;
     let tag = x3[j..k].try_into().unwrap();
-    if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), &mut x3[i..j], tag) {
+    if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), &mut x3[i..j], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let identity_start = i;
     let identity_end = j;
 
-    let (kek_send, kek_recv) = noise.get_ask(LABEL_KEX_KEY);
-    let c = INIT_COUNTER;
+    let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
+    let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
+    noise.get_ask(hmac, LABEL_KEX_KEY, &mut kek_send, &mut kek_recv);
+    let c = 0;
 
     let action = app.check_accept_session(&s_remote, &x3[identity_start..identity_end]);
     let responder_disallows_downgrade = action.responder_disallows_downgrade;
     let responder_silently_rejects = action.responder_silently_rejects;
     let session_data = action.session_data;
     let create_reject = || {
-        let mut d = Vec::<u8>::new();
-        let n = to_nonce(PACKET_TYPE_SESSION_REJECTED, c);
-        let tag = App::Aead::encrypt_in_place(&kek_send, n, None, &mut []);
-        d.extend(&tag);
         // We just used a counter with this key, but we are not storing
         // the fact we used it in memory. This is currently ok because the
         // handshake is being dropped, so nonce reuse can't happen.
-        Packet(zeta.kid_send.get(), n, d)
+        let mut d = ArrayVec::<u8, HEADERED_SESSION_REJECTED_SIZE>::new();
+        d.extend([0u8; HEADER_SIZE]);
+        let nonce = to_nonce(PACKET_TYPE_SESSION_REJECTED, c);
+        d.extend(App::Aead::encrypt_in_place((&kek_send[..AES_256_KEY_SIZE]).try_into().unwrap(), &nonce, &[], &mut []));
+        set_header(&mut d, zeta.kid_send.get(), &nonce);
+        d
     };
     if let Some(session_data) = session_data {
         let result = app.restore_by_identity(&s_remote, &session_data);
@@ -685,15 +748,22 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                         // TODO: add some kind of warning callback or signal.
                     } else {
                         if !responder_silently_rejects {
-                            send(&create_reject(), Some(&zeta.hk_send))
+                            send(&mut create_reject(), Some(&App::PrpEnc::new(&zeta.hk_send)))
                         }
                         return Err(byzantine_fault!(FailedAuth, true));
                     }
                 }
 
-                let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
+                let mut noise_kk_ss = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
+                if !ctx.s_secret.agree(&s_remote, &mut noise_kk_ss) {
+                    return Err(byzantine_fault!(FailedAuth, true));
+                }
+                let mut nk_recv = Zeroizing::new([0u8; HASHLEN]);
+                let mut nk_send = Zeroizing::new([0u8; HASHLEN]);
+                noise.split(hmac, &mut nk_send, &mut nk_recv);
+
+                let new_ratchet_state = create_ratchet_state(hmac, &mut noise, zeta.ratchet_state.chain_len);
                 // We must make sure the ratchet key is saved before we transition.
-                let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state.chain_len + 1);
                 let result = app.save_ratchet_state(
                     &s_remote,
                     &session_data,
@@ -709,77 +779,89 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     return Err(ReceiveError::RatchetIoError(e));
                 }
 
-                let mut c1 = Vec::new();
-                let n = to_nonce(PACKET_TYPE_KEY_CONFIRM, c);
-                let tag = App::Aead::encrypt_in_place(&kek_send, n, None, &mut []);
-                c1.extend(&tag);
+                let (session, current_time) = {
+                    let mut session_map = ctx.session_map.write().unwrap();
+                    use std::collections::hash_map::Entry::*;
+                    let entry = match session_map.entry(zeta.kid_recv) {
+                        // We could have issued the kid that we initially offered Alice to someone else
+                        // before Alice was able to respond. It is unlikely but possible.
+                        Occupied(_) => return Err(byzantine_fault!(OutOfSequence, false)),
+                        Vacant(entry) => entry,
+                    };
+                    let mut session_queue = ctx.session_queue.lock().unwrap();
+                    let queue_idx = session_queue.reserve_index();
+                    let current_time = app.time();
+                    let session = Arc::new(Session {
+                        session_data,
+                        was_bob: true,
+                        s_remote,
+                        send_counter: AtomicU64::new(c + 1),
+                        session_has_expired: AtomicBool::new(false),
+                        state_machine_lock: Mutex::new(()),
+                        state: RwLock::new(MutableState {
+                            ratchet_state1: new_ratchet_state.clone(),
+                            ratchet_state2: None,
+                            key_creation_counter: c + 1,
+                            key_index: false,
+                            keys: [DuplexKey::default(), DuplexKey::default()],
+                            resend_timer: current_time + App::SETTINGS.resend_time as i64,
+                            timeout_timer: current_time + App::SETTINGS.rekey_timeout as i64,
+                            beta: ZetaAutomata::S1,
+                        }),
+                        window: Window::new(),
+                        queue_idx,
+                        noise_kk_ss: noise_kk_ss.clone(),
+                        defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
+                        hk_send: App::PrpEnc::new(&zeta.hk_send),
+                        hk_recv: App::PrpDec::new(&zeta.hk_recv),
+                    });
 
-                let (nk1, nk2) = noise.split();
-                let keys = DuplexKey {
-                    send: Keys { kek: Some(kek_send), nk: Some(nk1), kid: Some(zeta.kid_send) },
-                    recv: Keys { kek: Some(kek_recv), nk: Some(nk2), kid: Some(zeta.kid_recv) },
+                    let mut state = session.state.write().unwrap();
+                    state.key_mut(false).replace_nk(&nk_send, &nk_recv);
+                    state.key_mut(false).recv.kid = Some(zeta.kid_recv);
+                    state.key_mut(false).recv.replace_kek(&kek_recv);
+                    state.key_mut(false).send.kid = Some(zeta.kid_send);
+                    state.key_mut(false).send.replace_kek(&kek_send);
+
+                    session_queue.push_reserved(queue_idx, Arc::downgrade(&session), Reverse(state.next_timer()));
+                    entry.insert(Arc::downgrade(&session));
+                    (session, current_time)
                 };
-                let current_time = app.time();
+                process_timers(app, ctx, &session, current_time, false, true, send);
 
-                let mut session_map = ctx.session_map.lock().unwrap();
-                use std::collections::hash_map::Entry::*;
-                let entry = match session_map.entry(zeta.kid_recv) {
-                    // We could have issued the kid that we initially offered Alice to someone else
-                    // before Alice was able to respond. It is unlikely but possible.
-                    Occupied(_) => return Err(byzantine_fault!(OutOfSequence, false)),
-                    Vacant(entry) => entry,
-                };
-                let session = Arc::new(Session(Mutex::new(Zeta {
-                    ctx: Arc::downgrade(ctx),
-                    session_data,
-                    was_bob: true,
-                    s_remote,
-                    send_counter: INIT_COUNTER + 1,
-                    key_creation_counter: INIT_COUNTER + 1,
-                    key_index: false,
-                    keys: [keys, DuplexKey::default()],
-                    ratchet_state1: new_ratchet_state,
-                    ratchet_state2: None,
-                    hk_send: zeta.hk_send.clone(),
-                    resend_timer: current_time + App::SETTINGS.resend_time as i64,
-                    timeout_timer: current_time + App::SETTINGS.rekey_timeout as i64,
-                    beta: ZetaAutomata::S1,
-                    counter_antireplay_window: std::array::from_fn(|_| 0),
-                    defrag: zeta.defrag,
-                })));
-                entry.insert(Arc::downgrade(&session));
-                ctx.sessions.lock().unwrap().insert(Arc::as_ptr(&session), Arc::downgrade(&session));
-
-                send(&Packet(zeta.kid_send.get(), n, c1), Some(&zeta.hk_send));
                 Ok(session)
             }
             Err(e) => Err(ReceiveError::RatchetIoError(e)),
         }
     } else {
         if !responder_silently_rejects {
-            send(&create_reject(), Some(&zeta.hk_send))
+            //send(&create_reject(), Some(&zeta.hk_send))
         }
         Err(byzantine_fault!(FailedAuth, true))
     }
 }
 /// Corresponds to Transition Algorithm 5 found in Section 4.3.
 pub(crate) fn received_c1_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
     app: &App,
-    rng: &Mutex<App::Rng>,
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
-    c1: Vec<u8>,
-    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+    n: &[u8; AES_GCM_IV_SIZE],
+    c1: &[u8],
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<bool, ReceiveError<App::StorageError>> {
     use FaultType::*;
 
     if c1.len() != KEY_CONFIRMATION_SIZE {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
-    let is_other = if Some(kid) == zeta.key_ref(true).recv.kid {
+
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let mut state = session.state.read().unwrap();
+
+    let is_other = if Some(kid) == state.key_ref(true).recv.kid {
         true
-    } else if Some(kid) == zeta.key_ref(false).recv.kid {
+    } else if Some(kid) == state.key_ref(false).recv.kid {
         false
     } else {
         // Some key confirmation may have arrived extremely delayed.
@@ -787,28 +869,28 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(OutOfSequence, false));
     };
 
-    let specified_key = zeta.key_ref(is_other).recv.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let specified_key = state.key_ref(is_other).recv.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = c1[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(specified_key, n, None, &mut [], tag) {
+    if !App::Aead::decrypt_in_place(specified_key, n, &[], &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let (_, c) = from_nonce(&n);
-    if !zeta.update_counter_window(c) {
+    let (_, c) = from_nonce(n);
+    if !session.window.update(c) {
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
 
-    let just_establised = is_other && matches!(&zeta.beta, ZetaAutomata::A3 { .. });
+    let just_establised = is_other && matches!(&state.beta, ZetaAutomata::A3 { .. });
     if is_other {
-        if let ZetaAutomata::A3 { .. } | ZetaAutomata::R2 { .. } = &zeta.beta {
-            if zeta.ratchet_state2.is_some() {
+        if let ZetaAutomata::A3 { .. } | ZetaAutomata::R2 { .. } = &state.beta {
+            if state.ratchet_state2.is_some() {
                 let result = app.save_ratchet_state(
-                    &zeta.s_remote,
-                    &zeta.session_data,
+                    &session.s_remote,
+                    &session.session_data,
                     RatchetUpdate {
-                        state1: &zeta.ratchet_state1,
+                        state1: &state.ratchet_state1,
                         state2: None,
                         state1_was_just_added: false,
-                        state_deleted1: zeta.ratchet_state2.as_ref(),
+                        state_deleted1: state.ratchet_state2.as_ref(),
                         state_deleted2: None,
                     },
                 );
@@ -816,127 +898,261 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
                     return Err(ReceiveError::RatchetIoError(e));
                 }
             }
+            drop(state);
+            let mut state_mut = session.state.write().unwrap();
 
-            zeta.ratchet_state2 = None;
-            zeta.key_index ^= true;
-            zeta.timeout_timer = app.time()
+            state_mut.ratchet_state2 = None;
+            state_mut.key_index ^= true;
+            state_mut.timeout_timer = app.time()
                 + App::SETTINGS
                     .rekey_after_time
-                    .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
-            zeta.resend_timer = i64::MAX;
-            zeta.beta = ZetaAutomata::S2;
+                    .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+            state_mut.resend_timer = i64::MAX;
+            state_mut.beta = ZetaAutomata::S2;
+            drop(state);
+            state = session.state.read().unwrap();
         }
     }
-    let mut c2 = Vec::new();
 
-    let c = zeta.send_counter;
-    zeta.send_counter += 1;
-    let n = to_nonce(PACKET_TYPE_ACK, c);
-    let latest_confirmed_key = zeta.key_ref(false).send.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
-    let tag = App::Aead::encrypt_in_place(latest_confirmed_key, n, None, &mut []);
-    c2.extend(&tag);
+    let mut c2 = ArrayVec::<u8, HEADERED_KEY_CONFIRMATION_SIZE>::new();
+    c2.extend([0u8; HEADER_SIZE]);
+    let (c, should_rekey) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
+    let nonce = to_nonce(PACKET_TYPE_ACK, c);
+    let latest_confirmed_key = state.key_ref(false).send.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    c2.extend(App::Aead::encrypt_in_place(latest_confirmed_key, &nonce, &[], &mut []));
+    let kid_send = state.key_ref(false).send.kid.ok_or(byzantine_fault!(OutOfSequence, false))?;
+    set_header(&mut c2, kid_send.get(), &nonce);
 
-    send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c2), Some(&zeta.hk_send));
+    send(&mut c2, Some(&session.hk_send));
     Ok(just_establised)
 }
 /// Corresponds to the trivial Transition Algorithm described for processing C_2 packets found in
 /// Section 4.3.
 pub(crate) fn received_c2_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
     app: &App,
-    rng: &Mutex<App::Rng>,
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
-    c2: Vec<u8>,
+    n: &[u8; AES_GCM_IV_SIZE],
+    c2: &[u8],
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
 
     if c2.len() != ACKNOWLEDGEMENT_SIZE {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
-    if Some(kid) != zeta.key_ref(false).recv.kid {
+
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let state = session.state.read().unwrap();
+
+    if Some(kid) != state.key_ref(false).recv.kid {
         // Some acknowledgement may have arrived extremely delayed.
         return Err(byzantine_fault!(UnknownLocalKeyId, false));
     }
-    if !matches!(&zeta.beta, ZetaAutomata::S1) {
+    if !matches!(&state.beta, ZetaAutomata::S1) {
         // Some acknowledgement may have arrived extremely delayed.
         return Err(byzantine_fault!(OutOfSequence, false));
     }
 
     let tag = c2[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), n, None, &mut [], tag) {
+    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let (_, c) = from_nonce(&n);
-    if !zeta.update_counter_window(c) {
+    let (_, c) = from_nonce(n);
+    if !session.window.update(c) {
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
+    drop(state);
+    let mut state = session.state.write().unwrap();
 
-    zeta.timeout_timer = app.time()
+    state.timeout_timer = app.time()
         + App::SETTINGS
             .rekey_after_time
-            .saturating_sub(rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
-    zeta.resend_timer = i64::MAX;
-    zeta.beta = ZetaAutomata::S2;
+            .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+    state.resend_timer = i64::MAX;
+    state.beta = ZetaAutomata::S2;
     Ok(())
 }
 /// Corresponds to the trivial Transition Algorithm described for processing D packets found in
 /// Section 4.3.
 pub(crate) fn received_d_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
+    app: &App,
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
-    d: Vec<u8>,
+    n: &[u8; AES_GCM_IV_SIZE],
+    d: &[u8],
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
 
     if d.len() != SESSION_REJECTED_SIZE {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
-    if Some(kid) != zeta.key_ref(true).recv.kid || !matches!(&zeta.beta, ZetaAutomata::A3 { .. }) {
+
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let state = session.state.read().unwrap();
+
+    if Some(kid) != state.key_ref(true).recv.kid || !matches!(&state.beta, ZetaAutomata::A3 { .. }) {
         return Err(byzantine_fault!(OutOfSequence, true));
     }
 
     let tag = d[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(true).recv.kek.as_ref().unwrap(), n, None, &mut [], tag) {
+    if !App::Aead::decrypt_in_place(state.key_ref(true).recv.kek.as_ref().unwrap(), n, &[], &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let (_, c) = from_nonce(&n);
-    if !zeta.update_counter_window(c) {
+    let (_, c) = from_nonce(n);
+    if !session.window.update(c) {
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
-
-    zeta.expire();
+    ///
+    //zeta.expire();
     Ok(())
 }
 /// Corresponds to the timer rules of the Zeta State Machine found in Section 4.1 - Definition 3.
-pub(crate) fn service<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    session: &Arc<Session<App>>,
-    ctx: &Arc<ContextInner<App>>,
+pub(crate) fn process_timers<App: ApplicationLayer>(
     app: &App,
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
     current_time: i64,
-    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+    force_timeout: bool,
+    force_resend: bool,
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) {
-    if zeta.timeout_timer <= current_time {
-        timeout_trans(zeta, session, app, ctx, current_time, send);
-    } else if zeta.resend_timer <= current_time {
-        // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
-        zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let mut state = session.state.read().unwrap();
+    if force_timeout || state.timeout_timer <= current_time {
+        // Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
+        match &state.beta {
+            ZetaAutomata::Null => {}
+            ZetaAutomata::A1(_) | ZetaAutomata::A3 { .. } => {
+                let identity = match &state.beta {
+                    ZetaAutomata::A1(a1) => &a1.identity,
+                    ZetaAutomata::A3 { identity, .. } => identity,
+                    _ => unreachable!(),
+                };
+                if matches!(&state.beta, ZetaAutomata::A1(_)) {
+                    log!(app, TimeoutX1(session));
+                } else {
+                    log!(app, TimeoutX3(session));
+                }
+                let new_kid_recv = remap(ctx, session, &state);
 
-        let (p, mut control_payload) = match &zeta.beta {
-            ZetaAutomata::Null => return,
-            ZetaAutomata::A1(StateA1 { packet, .. }) => {
-                log!(app, ResentX1(session));
-                return send(packet, None);
+                let mut hash = &mut App::Hash::new();
+                let mut hmac = &mut App::HmacHash::new();
+                if let Some(a1) = create_a1_state(
+                    hash,
+                    hmac,
+                    &ctx.rng,
+                    &session.s_remote,
+                    new_kid_recv,
+                    &state.ratchet_state1,
+                    state.ratchet_state2.as_ref(),
+                    identity,
+                ) {
+                    let mut hk_recv = Zeroizing::new([0u8; HASHLEN]);
+                    let mut hk_send = Zeroizing::new([0u8; HASHLEN]);
+                    a1.noise.get_ask(hmac, LABEL_HEADER_KEY, &mut hk_recv, &mut hk_send);
+                    let mut x1 = a1.x1.clone();
+
+                    drop(state);
+                    {
+                        let mut state = session.state.write().unwrap();
+                        session.hk_recv.reset((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap());
+                        session.hk_send.reset((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap());
+                        *state.key_mut(true) = DuplexKey::default();
+                        state.key_mut(true).recv.kid = Some(new_kid_recv);
+                        state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                        state.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
+                        state.beta = ZetaAutomata::A1(a1);
+                    }
+
+                    send(&mut x1, None);
+                } else {
+                    //zeta.expire();
+                }
             }
-            ZetaAutomata::A3 { packet, .. } => {
+            ZetaAutomata::S2 => {
+                // Corresponds to Transition Algorithm 6 found in Section 4.3.
+                log!(app, StartedRekeyingSentK1(session));
+                let new_kid_recv = remap(ctx, session, &state);
+                //    -> s
+                //    <- s
+                //    ...
+                //    -> psk, e, es, ss
+                let mut noise = SymmetricState::initialize(PROTOCOL_NAME_NOISE_KK);
+                let mut hash = &mut App::Hash::new();
+                let mut hmac = &mut App::HmacHash::new();
+                let mut k1 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
+                k1.extend([0u8; HEADER_SIZE]);
+                // Noise process prologue.
+                noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
+                noise.mix_hash(hash, &session.s_remote.to_bytes());
+                // Process message pattern 1 psk0 token.
+                noise.mix_key_and_hash(hash, hmac, state.ratchet_state1.key.as_ref());
+                // Process message pattern 1 e token.
+                let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut k1);
+                // Process message pattern 1 es token.
+                if noise.mix_dh(hmac, &e_secret, &session.s_remote).is_none() {
+                    //zeta.expire();
+                    return;
+                }
+                // Process message pattern 1 ss token.
+                noise.mix_key(hmac, session.noise_kk_ss.as_ref());
+                // Process message pattern 1 payload.
+                let i = k1.len();
+                k1.extend(new_kid_recv.get().to_be_bytes());
+                k1.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..]));
+
+                drop(state);
+                {
+                    let mut state = session.state.write().unwrap();
+                    state.key_mut(true).recv.kid = Some(new_kid_recv);
+                    state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
+                    state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                    state.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
+                }
+                let state = session.state.read().unwrap();
+
+                if let Some((c, should_rekey)) = get_counter(session, &state) {
+                    let nonce = to_nonce(PACKET_TYPE_REKEY_INIT, c);
+                    k1.extend(App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut k1));
+                    set_header(&mut k1, state.key_ref(false).send.kid.unwrap().get(), &nonce);
+
+                    send(&mut k1, Some(&session.hk_send));
+                }
+            }
+            ZetaAutomata::S1 { .. } => {
+                log!(app, TimeoutKeyConfirm(session));
+                //zeta.expire();
+            }
+            ZetaAutomata::R1 { .. } => {
+                log!(app, TimeoutK1(session));
+                //zeta.expire();
+            }
+            ZetaAutomata::R2 { .. } => {
+                log!(app, TimeoutK2(session));
+                //zeta.expire();
+            }
+        }
+    } else if force_resend || state.resend_timer <= current_time {
+        // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
+        state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+
+        let (packet_type, mut control_payload) = match &state.beta {
+            ZetaAutomata::Null => return,
+            ZetaAutomata::A1(a1) => {
+                log!(app, ResentX1(session));
+                return send(&mut a1.x1.clone(), None);
+            }
+            ZetaAutomata::A3 { x3, .. } => {
                 log!(app, ResentX3(session));
-                return send(packet, Some(&zeta.hk_send));
+                return send(&mut x3.clone(), Some(&session.hk_send));
             }
             ZetaAutomata::S1 => {
                 log!(app, ResentKeyConfirm(session));
-                (PACKET_TYPE_KEY_CONFIRM, Vec::new())
+                let mut c1 = ArrayVec::new();
+                c1.extend([0u8; HEADER_SIZE]);
+                (PACKET_TYPE_KEY_CONFIRM, c1)
             }
             ZetaAutomata::S2 => return,
             ZetaAutomata::R1 { k1, .. } => {
@@ -948,142 +1164,37 @@ pub(crate) fn service<App: ApplicationLayer>(
                 (PACKET_TYPE_REKEY_COMPLETE, k2.clone())
             }
         };
-        let c = zeta.send_counter;
-        zeta.send_counter += 1;
-        let n = to_nonce(p, c);
-        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut control_payload);
-        control_payload.extend(&tag);
-        send(
-            &Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, control_payload),
-            Some(&zeta.hk_send),
-        );
+        if let Some((c, should_rekey)) = get_counter(session, &state) {
+            let nonce = to_nonce(packet_type, c);
+            let tag = App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut control_payload);
+            control_payload.extend(tag);
+            set_header(&mut control_payload, state.key_ref(false).send.kid.unwrap().get(), &nonce);
+
+            send(&mut control_payload, Some(&session.hk_send));
+        }
     }
 }
-fn remap<App: ApplicationLayer>(session: &Arc<Session<App>>, zeta: &Zeta<App>, rng: &Mutex<App::Rng>, session_map: &SessionMap<App>) -> NonZeroU32 {
-    let mut session_map = session_map.lock().unwrap();
-    let weak = if let Some(Some(weak)) = zeta.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
+fn remap<App: ApplicationLayer>(ctx: &Arc<ContextInner<App>>, session: &Arc<Session<App>>, state: &MutableState<App>) -> NonZeroU32 {
+    let mut session_map = ctx.session_map.write().unwrap();
+    let weak = if let Some(Some(weak)) = state.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
         weak
     } else {
         Arc::downgrade(&session)
     };
-    let new_kid_recv = gen_kid(session_map.deref(), rng.lock().unwrap().deref_mut());
+    let new_kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
     session_map.insert(new_kid_recv, weak);
     new_kid_recv
 }
-/// Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
-fn timeout_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    session: &Arc<Session<App>>,
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
-    current_time: i64,
-    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) {
-    match &zeta.beta {
-        ZetaAutomata::Null => {}
-        ZetaAutomata::A1(StateA1 { identity, .. }) | ZetaAutomata::A3 { identity, .. } => {
-            if matches!(&zeta.beta, ZetaAutomata::A1(_)) {
-                log!(app, TimeoutX1(session));
-            } else {
-                log!(app, TimeoutX3(session));
-            }
-            let new_kid_recv = remap(session, &zeta, &ctx.rng, &ctx.session_map);
-
-            if let Some(a1) = create_a1_state(
-                &ctx.rng,
-                &zeta.s_remote,
-                new_kid_recv,
-                &zeta.ratchet_state1,
-                zeta.ratchet_state2.as_ref(),
-                identity.clone(),
-            ) {
-                let (hk_recv, hk_send) = a1.noise.get_ask(LABEL_HEADER_KEY);
-                let packet = a1.packet.clone();
-
-                zeta.hk_send = hk_send;
-                *zeta.key_mut(true) = DuplexKey::default();
-                zeta.key_mut(true).recv.kid = Some(new_kid_recv);
-                zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
-                zeta.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
-                zeta.beta = ZetaAutomata::A1(a1);
-                zeta.defrag = DefragBuffer::new(Some(hk_recv));
-
-                send(&packet, None);
-            } else {
-                zeta.expire();
-            }
-        }
-        ZetaAutomata::S2 => {
-            // Corresponds to Transition Algorithm 6 found in Section 4.3.
-            log!(app, StartedRekeyingSentK1(session));
-            let new_kid_recv = remap(session, &zeta, &ctx.rng, &ctx.session_map);
-            //    -> s
-            //    <- s
-            //    ...
-            //    -> psk, e, es, ss
-            let mut k1 = Vec::new();
-            let mut noise = SymmetricState::initialize(PROTOCOL_NAME_NOISE_KK);
-            // Noise process prologue.
-            noise.mix_hash(&ctx.s_secret.public_key_bytes());
-            noise.mix_hash(&zeta.s_remote.to_bytes());
-            // Process message pattern 1 psk0 token.
-            noise.mix_key_and_hash(zeta.ratchet_state1.key.as_ref());
-            // Process message pattern 1 e token.
-            let e_secret = noise.write_e(&ctx.rng, &mut k1);
-            // Process message pattern 1 es token.
-            if noise.mix_dh(&e_secret, &zeta.s_remote).is_none() {
-                zeta.expire();
-                return;
-            }
-            // Process message pattern 1 ss token.
-            if noise.mix_dh(&ctx.s_secret, &zeta.s_remote).is_none() {
-                zeta.expire();
-                return;
-            }
-            // Process message pattern 1 payload.
-            let i = k1.len();
-            k1.extend(&new_kid_recv.get().to_be_bytes());
-            noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_INIT, 0), i, &mut k1);
-
-            zeta.key_mut(true).recv.kid = Some(new_kid_recv);
-            zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-            zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
-            zeta.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
-
-            let c = zeta.send_counter;
-            zeta.send_counter += 1;
-            let n = to_nonce(PACKET_TYPE_REKEY_INIT, c);
-            let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k1);
-            k1.extend(&tag);
-
-            send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k1), Some(&zeta.hk_send));
-        }
-        ZetaAutomata::S1 { .. } => {
-            log!(app, TimeoutKeyConfirm(session));
-            zeta.expire();
-        }
-        ZetaAutomata::R1 { .. } => {
-            log!(app, TimeoutK1(session));
-            zeta.expire();
-        }
-        ZetaAutomata::R2 { .. } => {
-            log!(app, TimeoutK2(session));
-            zeta.expire();
-        }
-    }
-}
 /// Corresponds to Transition Algorithm 7 found in Section 4.3.
 pub(crate) fn received_k1_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    session: &Arc<Session<App>>,
     app: &App,
-    rng: &Mutex<App::Rng>,
-    session_map: &SessionMap<App>,
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
     s_secret: &App::KeyPair,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
-    mut k1: Vec<u8>,
-    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+    n: &[u8; AES_GCM_IV_SIZE],
+    k1: &mut [u8],
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    -> s
@@ -1094,13 +1205,17 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     if k1.len() != REKEY_SIZE {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
-    if Some(kid) != zeta.key_ref(false).recv.kid {
+
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let state = session.state.read().unwrap();
+
+    if Some(kid) != state.key_ref(false).recv.kid {
         // Some rekey packet may have arrived extremely delayed.
         return Err(byzantine_fault!(UnknownLocalKeyId, false));
     }
-    let should_rekey_as_bob = match &zeta.beta {
+    let should_rekey_as_bob = match &state.beta {
         ZetaAutomata::S2 { .. } => true,
-        ZetaAutomata::R1 { .. } => zeta.was_bob,
+        ZetaAutomata::R1 { .. } => session.was_bob,
         _ => false,
     };
     if !should_rekey_as_bob {
@@ -1110,285 +1225,229 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 
     let i = k1.len() - AES_GCM_TAG_SIZE;
     let tag = k1[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), n, None, &mut k1[..i], tag) {
+    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut k1[..i], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let (_, c) = from_nonce(&n);
-    if !zeta.update_counter_window(c) {
+    let (_, c) = from_nonce(n);
+    if !session.window.update(c) {
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
-    k1.truncate(i);
 
     let result = (|| {
         let mut i = 0;
         let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_KK);
+        let mut hash = &mut App::Hash::new();
+        let mut hmac = &mut App::HmacHash::new();
         // Noise process prologue.
-        noise.mix_hash(&zeta.s_remote.to_bytes());
-        noise.mix_hash(&s_secret.public_key_bytes());
+        noise.mix_hash(hash, &session.s_remote.to_bytes());
+        noise.mix_hash(hash, &s_secret.public_key_bytes());
         // Process message pattern 1 psk0 token.
-        noise.mix_key_and_hash(zeta.ratchet_state1.key.as_ref());
+        noise.mix_key_and_hash(hash, hmac, state.ratchet_state1.key.as_ref());
         // Process message pattern 1 e token.
-        let e_remote = noise.read_e(&mut i, &k1).ok_or(byzantine_fault!(FailedAuth, true))?;
+        let e_remote = noise.read_e(hash, hmac, &mut i, &k1).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 es token.
-        noise.mix_dh(s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise.mix_dh(hmac, s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 ss token.
-        noise.mix_dh(s_secret, &zeta.s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise.mix_key(hmac, session.noise_kk_ss.as_ref());
         // Process message pattern 1 payload.
         let j = i + KID_SIZE;
         let k = j + AES_GCM_TAG_SIZE;
         let tag = k1[j..k].try_into().unwrap();
-        if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..j], tag) {
+        if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..j], tag) {
             return Err(byzantine_fault!(FailedAuth, true));
         }
         let kid_send = NonZeroU32::new(u32::from_be_bytes(k1[i..j].try_into().unwrap())).ok_or(byzantine_fault!(FailedAuth, true))?;
 
-        let mut k2 = Vec::new();
+        let mut k2 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
+        k2.extend([0u8; HEADER_SIZE]);
         // Process message pattern 2 e token.
-        let e_secret = noise.write_e(rng, &mut k2);
+        let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut k2);
         // Process message pattern 2 ee token.
-        noise.mix_dh(&e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise.mix_dh(hmac, &e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 se token.
-        noise.mix_dh(&s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise.mix_dh(hmac, &s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 payload.
         let i = k2.len();
-        let new_kid_recv = remap(session, &zeta, rng, session_map);
-        k2.extend(&new_kid_recv.get().to_be_bytes());
-        noise.encrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), i, &mut k2);
+        let new_kid_recv = remap(ctx, session, &state);
+        k2.extend(new_kid_recv.get().to_be_bytes());
+        k2.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..]));
 
-        let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
-        let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
+        let new_ratchet_state = create_ratchet_state(hmac, &noise, state.ratchet_state1.chain_len);
         let result = app.save_ratchet_state(
-            &zeta.s_remote,
-            &zeta.session_data,
+            &session.s_remote,
+            &session.session_data,
             RatchetUpdate {
                 state1: &new_ratchet_state,
-                state2: Some(&zeta.ratchet_state1),
+                state2: Some(&state.ratchet_state1),
                 state1_was_just_added: true,
-                state_deleted1: zeta.ratchet_state2.as_ref(),
+                state_deleted1: state.ratchet_state2.as_ref(),
                 state_deleted2: None,
             },
         );
         if let Err(e) = result {
             return Err(ReceiveError::RatchetIoError(e));
         }
-        let (kek_send, kek_recv) = noise.get_ask(LABEL_KEX_KEY);
-        let (nk_send, nk_recv) = noise.split();
 
-        zeta.key_mut(true).send.kid = Some(kid_send);
-        zeta.key_mut(true).send.kek = Some(kek_send);
-        zeta.key_mut(true).send.nk = Some(nk_send);
-        zeta.key_mut(true).recv.kid = Some(new_kid_recv);
-        zeta.key_mut(true).recv.kek = Some(kek_recv);
-        zeta.key_mut(true).recv.nk = Some(nk_recv);
-        zeta.ratchet_state2 = Some(zeta.ratchet_state1.clone());
-        zeta.ratchet_state1 = new_ratchet_state;
-        let current_time = app.time();
-        zeta.key_creation_counter = zeta.send_counter;
-        zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-        zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
-        zeta.beta = ZetaAutomata::R2 { k2: k2.clone() };
+        let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
+        let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
+        let mut nk_recv = Zeroizing::new([0u8; HASHLEN]);
+        let mut nk_send = Zeroizing::new([0u8; HASHLEN]);
+        noise.get_ask(hmac, LABEL_KEX_KEY, &mut kek_send, &mut kek_recv);
+        noise.split(hmac, &mut nk_send, &mut nk_recv);
 
-        let c = zeta.send_counter;
-        zeta.send_counter += 1;
-        let n = to_nonce(PACKET_TYPE_REKEY_COMPLETE, c);
-        let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut k2);
-        k2.extend(&tag);
+        drop(state);
+        {
+            let mut state = session.state.write().unwrap();
+            state.key_mut(true).replace_nk(&nk_send, &nk_recv);
+            state.key_mut(true).send.kid = Some(kid_send);
+            state.key_mut(true).send.replace_kek(&kek_send);
+            state.key_mut(true).recv.kid = Some(new_kid_recv);
+            state.key_mut(true).recv.replace_kek(&kek_recv);
+            state.ratchet_state2 = Some(state.ratchet_state1.clone());
+            state.ratchet_state1 = new_ratchet_state.clone();
+            let current_time = app.time();
+            state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
+            state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
+            state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            state.beta = ZetaAutomata::R2 { k2: k2.clone() };
+        }
+        let mut state = session.state.read().unwrap();
 
-        send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, k2), Some(&zeta.hk_send));
+        ///
+        let (c, should_rekey) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
+        let nonce = to_nonce(PACKET_TYPE_REKEY_COMPLETE, c);
+        k2.extend(App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut k2));
+        set_header(&mut k2, state.key_ref(false).send.kid.unwrap().get(), &nonce);
+
+        send(&mut k2, Some(&session.hk_send));
         Ok(())
     })();
+    ///
     if matches!(result, Err(ReceiveError::ByzantineFault { .. })) {
-        zeta.expire();
+        //zeta.expire();
     }
     result
 }
 /// Corresponds to Transition Algorithm 8 found in Section 4.3.
 pub(crate) fn received_k2_trans<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
     app: &App,
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
-    mut k2: Vec<u8>,
-    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
+    n: &[u8; AES_GCM_IV_SIZE],
+    mut k2: &mut [u8],
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    <- e, ee, se
     if k2.len() != REKEY_SIZE {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
-    if Some(kid) != zeta.key_ref(false).recv.kid {
+
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let state = session.state.read().unwrap();
+
+    if Some(kid) != state.key_ref(false).recv.kid {
         // Some rekey packet may have arrived extremely delayed.
         return Err(byzantine_fault!(UnknownLocalKeyId, false));
     }
-    if !matches!(&zeta.beta, ZetaAutomata::R1 { .. }) {
+    if !matches!(&state.beta, ZetaAutomata::R1 { .. }) {
         // Some rekey packet may have arrived extremely delayed.
         return Err(byzantine_fault!(OutOfSequence, false));
     }
 
     let i = k2.len() - AES_GCM_TAG_SIZE;
     let tag = k2[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(zeta.key_ref(false).recv.kek.as_ref().unwrap(), n, None, &mut k2[..i], tag) {
+    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut k2[..i], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let (_, c) = from_nonce(&n);
-    if !zeta.update_counter_window(c) {
+    let (_, c) = from_nonce(n);
+    if !session.window.update(c) {
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
-    k2.truncate(i);
     let result = (|| {
-        if let ZetaAutomata::R1 { noise, e_secret, .. } = &zeta.beta {
+        if let ZetaAutomata::R1 { noise, e_secret, .. } = &state.beta {
             let mut noise = noise.clone();
             let mut i = 0;
+            let mut hash = &mut App::Hash::new();
+            let mut hmac = &mut App::HmacHash::new();
             // Process message pattern 2 e token.
-            let e_remote = noise.read_e(&mut i, &k2).ok_or(byzantine_fault!(FailedAuth, true))?;
+            let e_remote = noise.read_e(hash, hmac, &mut i, &k2).ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 ee token.
-            noise.mix_dh(e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            noise.mix_dh(hmac, e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 se token.
-            noise.mix_dh(e_secret, &zeta.s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            noise.mix_dh(hmac, e_secret, &session.s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 payload.
             let j = i + KID_SIZE;
             let k = j + AES_GCM_TAG_SIZE;
             let tag = k2[j..k].try_into().unwrap();
-            if !noise.decrypt_and_hash_in_place(to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..j], tag) {
+            if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..j], tag) {
                 return Err(byzantine_fault!(FailedAuth, true));
             }
             let kid_send = NonZeroU32::new(u32::from_be_bytes(k2[i..j].try_into().unwrap())).ok_or(byzantine_fault!(InvalidPacket, true))?;
 
-            let (rk, rf) = noise.get_ask(LABEL_RATCHET_STATE);
-            let new_ratchet_state = RatchetState::new(rk, rf, zeta.ratchet_state1.chain_len + 1);
+            let new_ratchet_state = create_ratchet_state(hmac, &noise, state.ratchet_state1.chain_len);
             let result = app.save_ratchet_state(
-                &zeta.s_remote,
-                &zeta.session_data,
+                &session.s_remote,
+                &session.session_data,
                 RatchetUpdate {
                     state1: &new_ratchet_state,
                     state2: None,
                     state1_was_just_added: true,
-                    state_deleted1: Some(&zeta.ratchet_state1),
-                    state_deleted2: zeta.ratchet_state2.as_ref(),
+                    state_deleted1: Some(&state.ratchet_state1),
+                    state_deleted2: state.ratchet_state2.as_ref(),
                 },
             );
             if let Err(e) = result {
                 return Err(ReceiveError::RatchetIoError(e));
             }
-            let (kek_recv, kek_send) = noise.get_ask(LABEL_KEX_KEY);
-            let (nk_recv, nk_send) = noise.split();
+            let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
+            let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
+            let mut nk_recv = Zeroizing::new([0u8; HASHLEN]);
+            let mut nk_send = Zeroizing::new([0u8; HASHLEN]);
+            noise.get_ask(hmac, LABEL_KEX_KEY, &mut kek_recv, &mut kek_send);
+            noise.split(hmac, &mut nk_recv, &mut nk_send);
 
-            zeta.key_mut(true).send.kid = Some(kid_send);
-            zeta.key_mut(true).send.kek = Some(kek_send);
-            zeta.key_mut(true).send.nk = Some(nk_send);
-            zeta.key_mut(true).recv.kek = Some(kek_recv);
-            zeta.key_mut(true).recv.nk = Some(nk_recv);
-            zeta.ratchet_state1 = new_ratchet_state;
-            zeta.key_index ^= true;
-            let current_time = app.time();
-            zeta.key_creation_counter = zeta.send_counter;
-            zeta.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-            zeta.resend_timer = current_time + App::SETTINGS.resend_time as i64;
-            zeta.beta = ZetaAutomata::S1;
+            drop(state);
+            let current_time = {
+                let mut state = session.state.write().unwrap();
+                state.key_mut(true).replace_nk(&nk_send, &nk_recv);
+                state.key_mut(true).send.kid = Some(kid_send);
+                state.key_mut(true).send.replace_kek(&kek_send);
+                state.key_mut(true).recv.replace_kek(&kek_recv);
+                state.ratchet_state1 = new_ratchet_state.clone();
+                state.key_index ^= true;
+                let current_time = app.time();
+                state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
+                state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
+                state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                state.beta = ZetaAutomata::S1;
+                current_time
+            };
+            process_timers(app, ctx, session, current_time, false, true, send);
 
-            let mut c1 = Vec::new();
-            let c = zeta.send_counter;
-            zeta.send_counter += 1;
-            let n = to_nonce(PACKET_TYPE_KEY_CONFIRM, c);
-            let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.kek.as_ref().unwrap(), n, None, &mut []);
-            c1.extend(&tag);
-
-            send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, c1), Some(&zeta.hk_send));
             Ok(())
         } else {
             unreachable!()
         }
     })();
     if matches!(result, Err(ReceiveError::ByzantineFault { .. })) {
-        zeta.expire();
+        //zeta.expire();
     }
     result
 }
-/// Corresponds to Algorithm 9 found in Section 4.3.
-pub(crate) fn send_payload<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    mut payload: Vec<u8>,
-    send: impl FnOnce(&Packet, Option<&[u8; AES_256_KEY_SIZE]>),
-) -> Result<(), SendError> {
-    use SendError::*;
 
-    if matches!(&zeta.beta, ZetaAutomata::Null) {
-        return Err(SessionExpired);
-    }
-    if !matches!(
-        &zeta.beta,
-        ZetaAutomata::S1 | ZetaAutomata::S2 | ZetaAutomata::R1 { .. } | ZetaAutomata::R2 { .. }
-    ) {
-        return Err(SessionNotEstablished);
-    }
-    let c = zeta.send_counter;
-    zeta.send_counter += 1;
-    if c >= zeta.key_creation_counter + App::SETTINGS.rekey_after_key_uses {
-        if c >= zeta.key_creation_counter + EXPIRE_AFTER_USES {
-            zeta.expire();
-        } else {
-            // Cause timeout to occur next service interval.
-            zeta.timeout_timer = i64::MIN;
-        }
-    }
+//impl<App: ApplicationLayer> Session<App> {
+//    /// Mark a session as expired. This will make it impossible for this session to successfully
+//    /// receive or send data or control packets. It is recommended to simply `drop` the session
+//    /// instead, but this can provide some reassurance in complex shared ownership situations.
+//    pub fn expire(&mut self) {
+//        self.0.lock().unwrap().expire();
+//    }
+//}
 
-    let n = to_nonce(PACKET_TYPE_DATA, c);
-    let tag = App::Aead::encrypt_in_place(zeta.key_ref(false).send.nk.as_ref().unwrap(), n, None, &mut payload);
-    payload.extend(&tag);
-
-    send(&Packet(zeta.key_ref(false).send.kid.unwrap().get(), n, payload), Some(&zeta.hk_send));
-    Ok(())
-}
-/// Corresponds to Algorithm 10 found in Section 4.3.
-pub(crate) fn received_payload_in_place<App: ApplicationLayer>(
-    zeta: &mut Zeta<App>,
-    kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
-    payload: &mut Vec<u8>,
-) -> Result<(), ReceiveError<App::StorageError>> {
-    use FaultType::*;
-
-    if payload.len() < AES_GCM_TAG_SIZE {
-        return Err(byzantine_fault!(FailedAuth, true));
-    }
-    let is_other = if Some(kid) == zeta.key_ref(true).recv.kid {
-        true
-    } else if Some(kid) == zeta.key_ref(false).recv.kid {
-        false
-    } else {
-        // A packet would have to be delayed by around an hour for this error to occur, but it can
-        // occur naturally due to just out-of-order transport.
-        return Err(byzantine_fault!(OutOfSequence, false));
-    };
-
-    let i = payload.len() - AES_GCM_TAG_SIZE;
-    let specified_key = zeta.key_ref(is_other).recv.nk.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
-    let tag = payload[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(specified_key, n, None, &mut payload[..i], tag) {
-        return Err(byzantine_fault!(FailedAuth, true));
-    }
-    let (_, c) = from_nonce(&n);
-    if !zeta.update_counter_window(c) {
-        // This error is marked as not happening naturally, but it could occur if something about
-        // the transport protocol is duplicating packets.
-        return Err(byzantine_fault!(ExpiredCounter, true));
-    }
-    payload.truncate(i);
-
-    Ok(())
-}
-
-impl<App: ApplicationLayer> Session<App> {
-    /// Mark a session as expired. This will make it impossible for this session to successfully
-    /// receive or send data or control packets. It is recommended to simply `drop` the session
-    /// instead, but this can provide some reassurance in complex shared ownership situations.
-    pub fn expire(&mut self) {
-        self.0.lock().unwrap().expire();
-    }
-}
-
-impl<App: ApplicationLayer> Drop for Session<App> {
-    fn drop(&mut self) {
-        self.expire();
-    }
-}
+//impl<App: ApplicationLayer> Drop for Session<App> {
+//    fn drop(&mut self) {
+//        self.expire();
+//    }
+//}
diff --git a/src/zssp.rs b/src/zssp.rs
index 2288a43..ef49568 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -19,14 +19,15 @@ use std::sync::{Arc, Mutex, MutexGuard, RwLock, Weak};
 use arrayvec::ArrayVec;
 use zeroize::Zeroizing;
 
+use crate::zeta::*;
 use crate::challenge::ChallengeContext;
-use crate::crypto::aes::{AesDec, AesEnc, AES_256_KEY_SIZE};
+use crate::crypto::aes::{AesDec, AesEnc, AES_256_KEY_SIZE, AES_GCM_TAG_SIZE, AES_GCM_IV_SIZE};
 use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
 use crate::crypto::pqc_kyber::KYBER_SECRETKEYBYTES;
 use crate::crypto::rand_core::RngCore;
 use crate::crypto::sha512::{HmacSha512, HashSha512};
 
-use crate::result::{FaultType, OpenError, ReceiveError, SendError};
+use crate::result::{FaultType, OpenError, ReceiveError, SendError, ReceiveOk, byzantine_fault, SessionEvent};
 use crate::frag_cache::UnassociatedFragCache;
 use crate::fragged::{Assembled, Fragged};
 use crate::handshake_cache::UnassociatedHandshakeCache;
@@ -36,6 +37,15 @@ use crate::proto::*;
 use crate::symmetric_state::SymmetricState;
 use crate::{applicationlayer::*, RatchetState};
 
+/// Macro to turn off logging at compile time.
+macro_rules! log {
+    ($app:expr, $event:expr) => {
+        #[cfg(feature = "logging")]
+        $app.event_log($event);
+    };
+}
+pub(crate) use log;
+
 /// Session context for local application.
 ///
 /// Each application using ZSSP must create an instance of this to own sessions and
@@ -48,60 +58,19 @@ impl<Application: ApplicationLayer> Clone for Context<Application> {
         Self(self.0.clone())
     }
 }
-pub struct ContextInner<Application: ApplicationLayer> {
-    static_keypair: Application::KeyPair,
-    unassociated_defrag_cache: Mutex<UnassociatedFragCache<Application::IncomingPacketBuffer>>,
-    unassociated_handshake_states: UnassociatedHandshakeCache<Application>,
-    /// `session_queue -> state_machine_lock -> state -> session_map`
-    session_queue: Mutex<IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>>,
-    session_map: RwLock<HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>>,
-    challenge: ChallengeContext,
-    rng: Mutex<Application::Rng>,
-}
 
-/// Result generated by the context packet receive function, with possible payloads.
-pub enum ReceiveResult<'b, Application: ApplicationLayer> {
-    /// Packet superficially appeared valid but is not associated with a session yet.
-    /// This can occur because the packet was only a fragment of a larger packet,
-    /// or if it was a control packet that does not go through full Noise authentication.
-    Unassociated,
-    /// Packet was authentic and belongs to this specific session.
-    Session(Arc<Session<Application>>, SessionEvent<'b>),
-    /// Packet was a part of a handshake, and while it superficially appeared valid the application
-    /// explicitly rejected it.
-    /// Relates to callbacks `check_allow_incoming_session`, `hello_requires_recognized_ratchet`
-    /// and `check_accept_session`.
-    Rejected,
-}
+pub(crate) type SessionMap<App> = RwLock<HashMap<NonZeroU32, Weak<Session<App>>>>;
+pub(crate) struct ContextInner<App: ApplicationLayer> {
+    pub rng: Mutex<App::Rng>,
+    pub(crate) s_secret: App::KeyPair,
+    pub(crate) session_queue: Mutex<IndexedBinaryHeap<Weak<Session<App>>, Reverse<i64>>>,
+    pub(crate) session_map: SessionMap<App>,
+    pub(crate) unassociated_defrag_cache: Mutex<UnassociatedFragCache<App::IncomingPacketBuffer>>,
+    pub(crate) unassociated_handshake_states: UnassociatedHandshakeCache<App>,
+    //pub(crate) b2_map: Mutex<HashMap<NonZeroU32, StateB2<App>>>,
 
-#[derive(Debug, PartialEq, Eq)]
-pub enum SessionEvent<'b> {
-    /// The received packet was valid, and it contained the necessary keys to fully establish a new
-    /// session with Alice, the handshake initiator.
-    ///
-    /// If the session Arc returned is dropped, the session with this peer will be immediately
-    /// terminated. Save the session Arc to some long lived datastructure to keep it alive.
-    NewSession,
-    /// When Alice calls `Context::open`, a session will be created, but Bob will not yet have
-    /// received this session. They will have to successfully complete a handshake first.
-    ///
-    /// Alice will receive this return value when the received packet confirms both parties
-    /// have completed the initial handshake and now have a shared session with each other.
-    /// If according to the upper protocol, Bob is the first party to send data, it is possible for
-    /// Alice to start receiving data from Bob before this value is returned.
-    ///
-    /// This return value can only occur once per session, only for session objects that were
-    /// created with `Context::open`.
-    Established,
-    /// Bob explicitly refused to establish a session with Alice, and sent us an error code.
-    /// The application should immediately drop this session as Bob will not allow us to connect.
-    ///
-    /// This return value cannot occur after a session is fully established.
-    Rejected,
-    /// The received packet was valid and a data payload was decoded and authenticated.
-    Data(&'b mut [u8]),
-    /// The received packet was some authentic protocol control packet. No action needs to be taken.
-    Control,
+    //hello_defrag: Mutex<DefragBuffer>,
+    pub(crate) challenge: ChallengeContext,
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -111,333 +80,33 @@ pub enum IncomingSessionAction {
     Drop,
 }
 
-/// ZeroTier Secure Session Protocol (ZSSP) Session
-///
-/// A FIPS/NIST compliant variant of Noise_XK with hybrid Kyber1024 PQ data forward secrecy.
-pub struct Session<App: ApplicationLayer> {
-    /// An arbitrary application defined object associated with each session.
-    pub application_data: App::SessionData,
-    /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
-    pub was_bob: bool,
-    /// The receive context associated with this session,
-    /// only this context can receive messages from the remote peer.
-    context: Weak<ContextInner<App>>,
-    /// Handle into the session queue for changing the update timer.
-    queue_idx: BinaryHeapIndex,
-
-    remote_static_key: App::PublicKey,
-    send_counter: AtomicU64,
-    /// This bool signals to all threads to stop incrementing the counter and instead error out.
-    session_has_expired: AtomicBool,
-    /// The following is a ring buffer of previously seen counter values, where we use the counter's
-    /// value as the index of the head of the ring buffer.
-    counter_antireplay_window: [AtomicU64; COUNTER_WINDOW_MAX_OOO],
-    /// Enforces atomicity of state machine transitions.
-    /// There is a standard locking sequence,
-    /// it goes `session_queue -> state_machine_lock -> state -> session_map`.
-    /// Any lock can be skipped but they must be locked in that order.
-    state_machine_lock: Mutex<()>,
-    state: RwLock<SessionMutableState<App>>,
-    defrag: [Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
-    header_send_cipher: App::PrpEnc,
-    header_receive_cipher: App::PrpDec,
-    kex_send_cipher: Mutex<Zeroizing<[u8; AES_256_KEY_SIZE]>>,
-    kex_receive_cipher: Mutex<Zeroizing<[u8; AES_256_KEY_SIZE]>>,
-    /// Pre-computed rekeying values.
-    noise_kk_ss: Zeroizing<[u8; P384_ECDH_SHARED_SECRET_SIZE]>,
-    noise_kk_local_init_h: [u8; HASHLEN],
-    noise_kk_remote_init_h: [u8; HASHLEN],
-}
-/// `AesGcm` is not threadsafe, but it is threadsafe when inside a `Mutex`.
-unsafe impl<Application: ApplicationLayer> Send for Session<Application> {}
-unsafe impl<Application: ApplicationLayer> Sync for Session<Application> {}
-
-/// Session state may only be mutated during atomic transitions of the offer state machine.
-struct SessionMutableState<Application: ApplicationLayer> {
-    ratchet_states: [RatchetState; 2],
-    /// For OOO rekeying reliability we allow our version of Noise CipherState to hold the last two
-    /// session keys, instead of just the most recent one.
-    cipher_states: [Option<SessionKey<Application>>; 2],
-    /// This is the index of `noise_cipher_state` that contains the most recent key.
-    /// It will be attached to fragment headers to help with OOO transport.
-    current_key: usize,
-    resent_timer: AtomicI64,
-    timeout_timer: i64,
-    /// This defines the exact state of the offer state machine we are in.
-    outgoing_offer: OfferStateMachine<Application>,
+fn parse_fragment_header<App: ApplicationLayer>(incoming_fragment: &[u8]) -> Result<(usize, usize, [u8; AES_GCM_IV_SIZE]), ReceiveError<App::StorageError>> {
+    let fragment_no = incoming_fragment[FRAGMENT_NO_IDX] as usize;
+    let fragment_count = incoming_fragment[FRAGMENT_COUNT_IDX] as usize;
+    if fragment_no >= fragment_count || fragment_count > MAX_FRAGMENTS {
+        return Err(byzantine_fault!(FaultType::InvalidPacket, true));
+    }
+    let mut nonce = [0u8; AES_GCM_IV_SIZE];
+    nonce[2..].copy_from_slice(&incoming_fragment[PACKET_NONCE_START..HEADER_SIZE]);
+    Ok((fragment_no, fragment_count, nonce))
 }
 
-/// These offer enums form a state machine.
-/// Documented below are the only legal transitions for this state machine.
-/// A session is initialized with an `outgoing_offer` of either NoiseXKPattern1 or Normal.
-enum OfferStateMachine<App: ApplicationLayer> {
-    Normal, // -> NoiseKKPattern1, NoiseKKPattern2
-    /// This state uses a lot of memory so we put it on the heap.
-    NoiseXKPattern1or3(Box<NoiseXKAliceHandshake<App>>), // -> Normal
-    NoiseKKPattern1 {
-        new_key_id: NonZeroU32,
-        noise_e_secret: App::KeyPair,
-        noise_message: ArrayVec<u8, REKEY_SIZE>,
-        noise_ck: SymmetricState<App>,
-    }, // -> NoiseKKPattern2, KeyConfirm
-    NoiseKKPattern2 {
-        noise_message: ArrayVec<u8, REKEY_SIZE>,
-        kex_send_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
-    }, // -> Normal
-    KeyConfirm, // -> Normal
-    Null,
-}
 
-pub(crate) struct NoiseXKBobHandshakeState<App: ApplicationLayer> {
-    /// Can never be Null.
-    ratchet_state: RatchetState,
-    remote_key_id: NonZeroU32,
-    local_key_id: NonZeroU32,
-    header_receive_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
-    header_send_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
-    noise_e_secret: App::KeyPair,
-    noise_ck_eseeekem1psk: SymmetricState<App>,
-    noise_pattern3_defrag: Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>,
-}
-
-struct NoiseXKAliceHandshake<App: ApplicationLayer> {
-    /// A secure random number put in the header of Alice's fragments to identify them.
-    /// If a DDOS attacker could guess this they could block Alice starting the handshake.
-    local_key_id: NonZeroU32,
-    alice_identity_blob: App::LocalIdentityBlob,
-    offer: NoiseXKAliceHandshakeState<App>,
-}
-
-enum NoiseXKAliceHandshakeState<App: ApplicationLayer> {
-    NoiseXKPattern1 {
-        noise_h_ee1p: [u8; HASHLEN],
-        noise_e_secret: App::KeyPair,
-        noise_e1_secret: App::Kem,
-        noise_ck_es: SymmetricState<App>,
-        /// ZSSP assumes an unreliable, out-of-order physical transport environment, so for that
-        /// reason we have to resend key offers.
-        noise_message: ArrayVec<u8, HANDSHAKE_HELLO_MAX_SIZE>,
-        message_id: u64,
-    },
-    NoiseXKPattern3 {
-        noise_message: ArrayVec<u8, HANDSHAKE_COMPLETION_MAX_SIZE>,
-    },
-}
-
-struct SessionKey<Application: ApplicationLayer> {
-    remote_key_id: NonZeroU32,
-    local_key_id: NonZeroU32,
-    /// Pool of reusable sending ciphers.
-    receive_cipher_pool: [Mutex<Application::AeadDec>; 8],
-    /// Pool of reusable receiving ciphers.
-    send_cipher_pool: [Mutex<Application::AeadEnc>; 8],
-    /// Rekey at or after this counter.
-    rekey_at_counter: u64,
-    /// Hard error when this counter value is reached or exceeded.
-    expire_at_counter: u64,
-}
-
-macro_rules! byzantine_fault {
-    ($name:expr, $is_natural:ident) => {
-        ReceiveError::ByzantineFault {
-            file: file!(),
-            line: line!(),
-            error: $name,
-            is_naturally_occurring: $is_natural,
-        }
-    };
-}
-
-impl<Application: ApplicationLayer> Context<Application> {
+impl<App: ApplicationLayer> Context<App> {
     /// Create a new session context.
-    pub fn new(static_keypair: Application::KeyPair, mut rng: Application::Rng) -> Self {
-        debug_assert!(Application::REKEY_AFTER_TIME_MAX_JITTER_MS > 0, "Invalid protocol constant");
-        let mut challenge_salt = [0u8; CHALLENGE_SALT_SIZE];
-        rng.fill_bytes(&mut challenge_salt);
+    pub fn new(static_secret_key: App::KeyPair, mut rng: App::Rng) -> Self {
+        let challenge = ChallengeContext::new(&mut rng);
         Self(Arc::new(ContextInner {
-            static_keypair,
+            rng: Mutex::new(rng),
+            s_secret: static_secret_key,
+            session_map: RwLock::new(HashMap::new()),
+            challenge,
+            session_queue: Mutex::new(IndexedBinaryHeap::new()),
             unassociated_defrag_cache: Mutex::new(UnassociatedFragCache::new()),
             unassociated_handshake_states: UnassociatedHandshakeCache::new(),
-            session_map: RwLock::new(HashMap::new()),
-            session_queue: Mutex::new(IndexedBinaryHeap::new()),
-            challenge_counter: AtomicU64::new(INIT_COUNTER),
-            challenge_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
-            challenge_salt,
-            rng: Mutex::new(rng),
         }))
     }
 
-    /// Perform periodic background service and cleanup tasks.
-    ///
-    /// This returns the number of milliseconds until it should be called again. The caller should
-    /// try to satisfy this but small variations in timing of up to +/- a second or two are not
-    /// a problem.
-    ///
-    /// * `send_to` - Function to get a sender and an MTU to send something over an active session
-    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
-    ///   with remote peers (although both of these properties would help reliability slightly).
-    ///   Used to determine if any current handshakes should be resent or timed-out, or if a session
-    ///   should rekey.
-    pub fn service<SendFn: FnMut(&mut [u8]) -> bool>(
-        &self,
-        app: &Application,
-        mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
-        current_time: i64,
-    ) -> i64 {
-        let retry_next = current_time.saturating_add(Application::RETRY_INTERVAL_MS);
-        let mut next_service_time = 2 * Application::RETRY_INTERVAL_MS;
-
-        let mut session_queue = self.0.session_queue.lock().unwrap();
-        // This update system takes heavy advantage of the fact that sessions only need to be updated
-        // either roughly every second or roughly every hour. That big gap allows for minor optimizations.
-        // If the gap changes (unlikely) this code may need to be rewritten.
-        while let Some((session, timer, queue_idx)) = session_queue.peek() {
-            if timer.0 >= current_time {
-                next_service_time = next_service_time.min(timer.0 - current_time);
-                break;
-            }
-            let session = match session.upgrade() {
-                Some(s) => s,
-                _ => {
-                    session_queue.remove(queue_idx);
-                    continue;
-                }
-            };
-            let state = session.state.read().unwrap();
-            use OfferStateMachine::*;
-            let next_timer = match &state.outgoing_offer {
-                Normal { timeout, .. } => {
-                    if *timeout <= current_time {
-                        drop(state);
-                        if let Some((send, _)) = send_to(&session) {
-                            let result = initiate_rekey(&self.0, &session, send, current_time);
-                            if result.is_ok() {
-                                app.event_log(LogEvent::ServiceKKStart(&session), current_time);
-                            }
-                            result.unwrap_or(retry_next)
-                        } else {
-                            retry_next
-                        }
-                    } else {
-                        *timeout
-                    }
-                }
-                // If there's an outstanding attempt to open a session, retransmit this
-                // periodically in case the initial packet doesn't make it.
-                NoiseXKPattern1or3(handshake_state) => {
-                    if let Some(ts) = process_timer(&handshake_state.next_retry_time, Application::RETRY_INTERVAL_MS, current_time) {
-                        ts
-                    } else {
-                        // We have to eventually time out NoiseXKPattern3 because of unreliable network conditions.
-                        if handshake_state.timeout <= current_time {
-                            drop(state);
-                            let _kex_lock = session.state_machine_lock.lock().unwrap();
-                            let mut state = session.state.write().unwrap();
-                            let ratchet_state = state.ratchet_states.clone();
-                            // Since we dropped the lock we must re-check if we are in the correct state.
-                            if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
-                                if handshake_state.timeout <= current_time {
-                                    app.event_log(LogEvent::ServiceXKTimeout(&session), current_time);
-                                    handshake_state.reinitialize(
-                                        &session,
-                                        &ratchet_state,
-                                        &mut self.0.session_map.write().unwrap(),
-                                        &mut self.0.rng.lock().unwrap(),
-                                        current_time,
-                                    );
-                                }
-                            }
-                        } else if let Some((mut send, mut mtu)) = send_to(&session) {
-                            mtu = mtu.max(MIN_TRANSPORT_MTU);
-                            match &handshake_state.offer {
-                                NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, message_id, .. } => {
-                                    app.event_log(LogEvent::ServiceXK1Resend(&session), current_time);
-                                    // We are in state NoiseXKPattern1 so resend noise_pattern1.
-                                    send_with_fragmentation(
-                                        &mut send,
-                                        mtu,
-                                        &mut noise_message.clone()[..*noise_message_len],
-                                        PACKET_TYPE_NOISE_XK_PATTERN_1,
-                                        None,
-                                        *message_id,
-                                        None::<&Application::PrpEnc>,
-                                    );
-                                }
-                                NoiseXKAliceHandshakeState::NoiseXKPattern3 { noise_message, noise_message_len, .. } => {
-                                    app.event_log(LogEvent::ServiceXK3Resend(&session), current_time);
-                                    send_with_fragmentation(
-                                        &mut send,
-                                        mtu,
-                                        &mut noise_message.clone()[..*noise_message_len],
-                                        PACKET_TYPE_NOISE_XK_PATTERN_3,
-                                        state.cipher_states[0].as_ref().map(|k| k.remote_key_id),
-                                        0,
-                                        Some(&session.header_send_cipher),
-                                    );
-                                }
-                            }
-                        }
-                        retry_next
-                    }
-                }
-                NoiseKKPattern1 { next_retry_time, timeout, noise_message, .. } | NoiseKKPattern2 { next_retry_time, timeout, noise_message, .. } => {
-                    if let Some(ts) = process_timer(next_retry_time, Application::RETRY_INTERVAL_MS, current_time) {
-                        ts
-                    } else {
-                        if *timeout <= current_time {
-                            app.event_log(LogEvent::ServiceKKTimeout(&session), current_time);
-                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
-                            drop(state);
-                            session.expire_inner(&self.0, &mut session_queue);
-                        } else {
-                            let packet_type = if let NoiseKKPattern1 { .. } = &state.outgoing_offer {
-                                app.event_log(LogEvent::ServiceKK1Resend(&session), current_time);
-                                PACKET_TYPE_NOISE_KK_PATTERN_1
-                            } else {
-                                app.event_log(LogEvent::ServiceKK2Resend(&session), current_time);
-                                PACKET_TYPE_NOISE_KK_PATTERN_2
-                            };
-                            if let Some((send, _)) = send_to(&session) {
-                                let _ = session.send_control(&state, send, packet_type, noise_message);
-                            }
-                        }
-                        retry_next
-                    }
-                }
-                KeyConfirm { next_retry_time, timeout, .. } => {
-                    if let Some(ts) = process_timer(next_retry_time, Application::RETRY_INTERVAL_MS, current_time) {
-                        ts
-                    } else {
-                        if *timeout <= current_time {
-                            app.event_log(LogEvent::ServiceKeyConfirmTimeout(&session), current_time);
-                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
-                            drop(state);
-                            session.expire_inner(&self.0, &mut session_queue);
-                        } else {
-                            app.event_log(LogEvent::ServiceKeyConfirmResend(&session), current_time);
-                            if let Some((send, _)) = send_to(&session) {
-                                let _ = session.send_control(&state, send, PACKET_TYPE_KEY_CONFIRM, &[]);
-                            }
-                        }
-                        retry_next
-                    }
-                }
-                Null => retry_next,
-            };
-            session_queue.change_priority(queue_idx, Reverse(next_timer));
-        }
-        drop(session_queue);
-
-        self.0
-            .unassociated_defrag_cache
-            .lock()
-            .unwrap()
-            .check_for_expiry(Application::INITIAL_OFFER_TIMEOUT_MS, current_time);
-        self.0.unassociated_handshake_states.service(current_time);
-
-        next_service_time
-    }
-
     /// Create a new session and send initial packet(s) to other side.
     ///
     /// This will return SendError::DataTooLarge if the combined size of the metadata and the local
@@ -454,103 +123,27 @@ impl<Application: ApplicationLayer> Context<Application> {
     ///   peer, or None if we do not have one.
     /// * `local_identity_blob` - Payload to be sent to Bob that contains the information necessary
     ///   for the upper protocol to authenticate and approve of Alice's identity.
-    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
-    /// with the remote peer. Used to determine when this offer should be resent.
     pub fn open(
         &self,
-        app: &Application,
+        app: App,
         mut send: impl FnMut(&mut [u8]) -> bool,
         mut mtu: usize,
-        remote_static_key: Application::PublicKey,
-        application_data: Application::SessionData,
-        local_identity_blob: Application::LocalIdentityBlob,
-        current_time: i64,
-    ) -> Result<Arc<Session<Application>>, OpenError<Application::StorageError>> {
+        static_remote_key: App::PublicKey,
+        session_data: App::SessionData,
+        identity: &[u8],
+    ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
         mtu = mtu.max(MIN_TRANSPORT_MTU);
-        if local_identity_blob.as_ref().len() > MAX_IDENTITY_BLOB_SIZE {
-            return Err(OpenError::DataTooLarge);
-        }
-        let result = app.restore_by_identity(&remote_static_key, &application_data, current_time);
-        match result {
-            Ok(ratchet_states) => {
-                let sha512 = &mut Application::Hash::new();
-
-                let mut noise_kk_ss = Secret::new();
-                if !self.0.static_keypair.agree(&remote_static_key, noise_kk_ss.as_mut()) {
-                    return Err(OpenError::InvalidPublicKey);
-                }
-                let noise_kk_local_init_h = mix_hash(sha512, &INITIAL_H_REKEY, self.0.static_keypair.public_key_bytes());
-                let noise_kk_local_init_h = mix_hash(sha512, &noise_kk_local_init_h, remote_static_key.as_bytes());
-                let noise_kk_remote_init_h = mix_hash(sha512, &INITIAL_H_REKEY, remote_static_key.as_bytes());
-                let noise_kk_remote_init_h = mix_hash(sha512, &noise_kk_remote_init_h, self.0.static_keypair.public_key_bytes());
-
-                let mut session_queue = self.0.session_queue.lock().unwrap();
-                let mut session_map = self.0.session_map.write().unwrap();
-                let local_key_id = generate_key_id(&session_map, &mut self.0.rng.lock().unwrap());
-                // Begin Noise XKhfs+psk2.
-                let (offer, a2b_header_key, b2a_header_key) = NoiseXKAliceHandshake::<Application>::initialize(
-                    local_key_id,
-                    &remote_static_key,
-                    &ratchet_states,
-                    &mut self.0.rng.lock().unwrap(),
-                )?;
-                let handshake_state = Box::new(NoiseXKAliceHandshake {
-                    next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-                    timeout: current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS),
-                    local_key_id,
-                    alice_identity_blob: local_identity_blob,
-                    offer,
-                });
-                if let NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, message_id, .. } = &handshake_state.offer {
-                    send_with_fragmentation(
-                        &mut send,
-                        mtu,
-                        &mut noise_message.clone()[..*noise_message_len],
-                        PACKET_TYPE_NOISE_XK_PATTERN_1,
-                        None,
-                        *message_id,
-                        None::<&Application::PrpEnc>,
-                    );
-                }
-
-                let queue_idx = session_queue.reserve_index();
-                let session = Arc::new(Session {
-                    context: Arc::downgrade(&self.0),
-                    queue_idx,
-                    application_data,
-                    remote_static_key,
-                    send_counter: AtomicU64::new(INIT_COUNTER),
-                    session_has_expired: AtomicBool::new(false),
-                    counter_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
-                    state_machine_lock: Mutex::new(()),
-                    state: RwLock::new(SessionMutableState {
-                        ratchet_states: ratchet_states.clone(),
-                        cipher_states: [None, None],
-                        // Points at 1 until the first key is confirmed.
-                        current_key: 1,
-                        outgoing_offer: OfferStateMachine::NoiseXKPattern1or3(handshake_state),
-                    }),
-                    header_send_cipher: Application::PrpEnc::new(a2b_header_key.as_ref()),
-                    header_receive_cipher: Application::PrpDec::new(b2a_header_key.as_ref()),
-                    kex_receive_cipher: Mutex::new(None),
-                    kex_send_cipher: Mutex::new(None),
-                    noise_kk_ss: noise_kk_ss.clone(),
-                    noise_kk_local_init_h,
-                    noise_kk_remote_init_h,
-                    defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
-                    was_bob: false,
-                });
-                session_map.insert(local_key_id, (Arc::downgrade(&session), false));
-                session_queue.push_reserved(
-                    queue_idx,
-                    Arc::downgrade(&session),
-                    Reverse(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-                );
-
-                Ok(session)
-            }
-            Err(e) => Err(OpenError::RatchetIoError(e)),
+        if identity.len() > IDENTITY_MAX_SIZE {
+            return Err(OpenError::IdentityTooLarge);
         }
+        // Process zeta layer.
+        trans_to_a1(
+            app,
+            &self.0,
+            static_remote_key,
+            session_data,
+            identity,
+        )
     }
 
     /// Receive, authenticate, decrypt, and process a physical wire packet.
@@ -562,7 +155,7 @@ impl<Application: ApplicationLayer> Context<Application> {
     /// The check_accept_session function is called at the end of negotiation for an incoming
     /// session with the caller's static public blob. It must return the P-384 static public key
     /// extracted from the supplied blob and application data. A return of Some() accepts the
-    /// session and will always result in a new session ReceiveResult being returned.
+    /// session and will always result in a new session ReceiveOk being returned.
     ///
     /// * `app` - Interface to application using ZSSP
     /// * `check_allow_incoming_session` - Function to call to check whether an unidentified new
@@ -586,21 +179,22 @@ impl<Application: ApplicationLayer> Context<Application> {
     ///   to put in-flight.
     pub fn receive<'a, SendFn: FnMut(&mut [u8]) -> bool>(
         &self,
-        app: &Application,
+        app: &App,
         check_allow_incoming_session: impl FnOnce() -> IncomingSessionAction,
-        check_accept_session: impl FnOnce(&Application::PublicKey, &[u8], u64) -> (Option<(bool, Application::SessionData)>, bool),
+        check_accept_session: impl FnOnce(&App::PublicKey, &[u8], u64) -> (Option<(bool, App::SessionData)>, bool),
         mut send_unassociated_reply: impl FnMut(&mut [u8]) -> bool,
         mut send_unassociated_mtu: usize,
-        mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
+        mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
         remote_address: &impl Hash,
         data_buf: &'a mut [u8],
-        mut incoming_physical_packet_buf: Application::IncomingPacketBuffer,
+        mut incoming_fragment_buf: App::IncomingPacketBuffer,
         current_time: i64,
-    ) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::StorageError>> {
+    ) -> Result<ReceiveOk<App>, ReceiveError<App::StorageError>> {
+        use crate::result::FaultType::*;
+        let ctx = &self.0;
         send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
-        let incoming_physical_packet: &mut [u8] = incoming_physical_packet_buf.as_mut();
-        let incoming_physical_packet_len = incoming_physical_packet.len();
-        if incoming_physical_packet_len < MIN_PACKET_SIZE {
+        let incoming_fragment: &mut [u8] = incoming_fragment_buf.as_mut();
+        if incoming_fragment.len() < MIN_PACKET_SIZE {
             return Err(byzantine_fault!(FaultType::InvalidPacket, false));
         }
 
@@ -611,80 +205,66 @@ impl<Application: ApplicationLayer> Context<Application> {
         let mut assembled_packet = Assembled::new(); // needs to outlive the block below
         let mut incoming = None;
         let (session, packet_type, fragments) = {
-            let local_key_id = incoming_physical_packet[0..SESSION_ID_SIZE].try_into().unwrap();
+            let kid_recv = incoming_fragment[0..KID_SIZE].try_into().unwrap();
             // `from_ne_bytes` because this id was generated locally.
-            if let Some(local_key_id) = NonZeroU32::new(u32::from_ne_bytes(local_key_id)) {
+            if let Some(kid_recv) = NonZeroU32::new(u32::from_ne_bytes(kid_recv)) {
                 let session_map = self.0.session_map.read().unwrap();
-                if let Some((Some(session), key_index)) = session_map.get(&local_key_id).map(|r| (r.0.upgrade(), r.1 as usize)) {
+                let session = ctx.session_map.read().unwrap().get(&kid_recv).map(|r| r.upgrade());
+                if let Some(Some(session)) = session {
                     drop(session_map);
-                    session.header_receive_cipher.decrypt_in_place(
-                        (&mut incoming_physical_packet[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END])
+                    session.hk_recv.decrypt_in_place(
+                        (&mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
                             .try_into()
                             .unwrap(),
                     );
-                    let (fragment_count, fragment_no, packet_type, incoming_counter, header_nonce) = parse_packet_header(incoming_physical_packet);
-                    // Handle replay protection.
-                    if PACKET_TYPE_RANGE_TRANSPORT.contains(&packet_type) {
-                        // For DOS resistant reply-protection we need to check that the given counter is
-                        // in the window of valid counters immediately.
-                        // But for packets larger than 1 fragment we can't actually record the
-                        // counter as received until we've authenticated the packet.
-                        // So we check the counter window twice, and only update it the second time
-                        // after the packet has been authenticated.
-                        if !session.check_receive_window(incoming_counter) {
-                            // This can occur naturally if packets arrive way out of order, or
-                            // if they are duplicates.
-                            // This can also be naturally triggered if Bob has just successfully
-                            // received the first session key and is reject all of Alice's resends.
-                            // This can also occur if a session was manually expired, but not
-                            // dropped, and the remote party is still sending us data.
-                            return Err(byzantine_fault!(FaultType::ExpiredCounter, true));
-                        }
+
+                    let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
+                    let (packet_type, incoming_counter) = from_nonce(&nonce);
+
+                    {//vrfy
                         if packet_type != PACKET_TYPE_DATA {
-                            // This is a control packet.
-                            if fragment_count != 1 || fragment_no > 0 {
-                                return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                            log!(app, ReceivedRawFragment(p, c, fragment_no, fragment_count));
+                        }
+                        if packet_type == PACKET_TYPE_HANDSHAKE_RESPONSE {
+                            if !matches!(&session.state.read().unwrap().beta, ZetaAutomata::A1(_)) {
+                                // A resent handshake response from Bob may have arrived out of order,
+                                // after we already received one.
+                                return Err(byzantine_fault!(OutOfSequence, false));
                             }
-                            return receive_control_fragment(
-                                self,
-                                session,
-                                app,
-                                send_to,
-                                packet_type,
-                                incoming_counter,
-                                incoming_physical_packet_buf.as_mut(),
-                                current_time,
-                            );
+                            if incoming_counter >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
+                                return Err(byzantine_fault!(ExpiredCounter, true));
+                            }
+                        } else if PACKET_TYPE_USES_COUNTER_RANGE.contains(&packet_type) {
+                            // For DOS resistant reply-protection we need to check that the given counter is
+                            // in the window of valid counters immediately.
+                            // But for packets larger than 1 fragment we can't actually record the
+                            // counter as received until we've authenticated the packet.
+                            // So we check the counter window twice, and only update it the second time
+                            // after the packet has been authenticated.
+                            if !session.window.check(incoming_counter) {
+                                // This can occur naturally if packets arrive way out of order, or
+                                // if they are duplicates.
+                                // This can also be naturally triggered if Bob has just successfully
+                                // received the first session key and is reject all of Alice's resends.
+                                // This can also occur if a session was manually expired, but not
+                                // dropped, and the remote party is still sending us data.
+                                return Err(byzantine_fault!(ExpiredCounter, false));
+                            }
+                        } else if packet_type == PACKET_TYPE_HANDSHAKE_COMPLETION {
+                            // This can be triggered if Bob successfully received a session key and
+                            // needs to reject all of Alice's resends of PACKET_TYPE_NOISE_XK_PATTERN_3.
+                            return Err(byzantine_fault!(InvalidPacket, false));
+                        } else {
+                            return Err(byzantine_fault!(InvalidPacket, true));
                         }
-                    } else if packet_type == PACKET_TYPE_NOISE_XK_PATTERN_2 {
-                        // We need to reject fragments marked with this type if they are sent out
-                        // of sequence, since an attacker is able to replay them.
-                        match &session.state.read().unwrap().outgoing_offer {
-                            OfferStateMachine::NoiseXKPattern1or3(handshake_state) => match &handshake_state.offer {
-                                NoiseXKAliceHandshakeState::NoiseXKPattern1 { .. } => {
-                                    if incoming_counter >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
-                                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                                    }
-                                }
-                                // This error can occur naturally if Bob's initial reply to Alice had a
-                                // resend that was delayed massively and arrived out of order.
-                                _ => return Err(byzantine_fault!(FaultType::OutOfSequence, true)),
-                            },
-                            _ => return Err(byzantine_fault!(FaultType::OutOfSequence, false)),
-                        };
-                    } else if packet_type == PACKET_TYPE_NOISE_XK_PATTERN_3 {
-                        // This can be triggered if Bob successfully received a session key and
-                        // needs to reject all of Alice's resends of PACKET_TYPE_NOISE_XK_PATTERN_3.
-                        return Err(byzantine_fault!(FaultType::OutOfSequence, true));
-                    } else {
-                        return Err(byzantine_fault!(FaultType::InvalidPacket, false));
                     }
+
                     // Handle defragmentation.
                     let fragments = if fragment_count > 1 {
                         let idx = incoming_counter as usize % session.defrag.len();
                         session.defrag[idx].lock().unwrap().assemble(
-                            header_nonce,
-                            incoming_physical_packet_buf,
+                            &nonce,
+                            incoming_fragment_buf,
                             fragment_no,
                             fragment_count,
                             &mut assembled_packet,
@@ -692,96 +272,100 @@ impl<Application: ApplicationLayer> Context<Application> {
                         if assembled_packet.is_empty() {
                             // We have not yet authenticated the sender so we do not report
                             // receiving a packet from them.
-                            return Ok(ReceiveResult::Unassociated);
+                            return Ok(ReceiveOk::Unassociated);
                         } else {
                             assembled_packet.as_ref()
                         }
                     } else {
-                        std::array::from_ref(&incoming_physical_packet_buf)
+                        std::slice::from_ref(&incoming_fragment_buf)
                     };
-                    // Handle DATA in the fastest path when we have a session.
-                    if packet_type == PACKET_TYPE_DATA {
-                        let state = session.state.read().unwrap();
-                        // The error here can occur because the other party is using a brand new
-                        // session key that we have not received yet.
-                        let key = state.cipher_states[key_index]
-                            .as_ref()
-                            .ok_or(byzantine_fault!(FaultType::OutOfSequence, true))?;
-                        let mut c = key.get_receive_cipher(incoming_counter);
-                        c.set_iv(&create_message_nonce(packet_type, incoming_counter));
 
-                        let mut data_len = 0;
+                    match packet_type {
+                        PACKET_TYPE_DATA => {
+                            let state = session.state.read().unwrap();
+                            // The error here can occur because the other party is using a brand new
+                            // session key that we have not received yet.
+                            let key = state.cipher_states[key_index]
+                                .as_ref()
+                                .ok_or(byzantine_fault!(FaultType::OutOfSequence, true))?;
+                            let mut c = key.get_receive_cipher(incoming_counter);
+                            c.set_iv(&create_message_nonce(packet_type, incoming_counter));
 
-                        // Decrypt fragments 0..N-1 where N is the number of fragments.
-                        for f in fragments[..(fragments.len() - 1)].iter() {
-                            let f: &[u8] = f.as_ref();
-                            debug_assert!(f.len() >= HEADER_SIZE);
+                            let mut data_len = 0;
+
+                            // Decrypt fragments 0..N-1 where N is the number of fragments.
+                            for f in fragments[..(fragments.len() - 1)].iter() {
+                                let f: &[u8] = f.as_ref();
+                                debug_assert!(f.len() >= HEADER_SIZE);
+                                let current_frag_data_start = data_len;
+                                data_len += f.len() - HEADER_SIZE;
+                                if data_len > data_buf.len() {
+                                    return Err(ReceiveError::DataBufferTooSmall);
+                                }
+                                c.decrypt(&f[HEADER_SIZE..], &mut data_buf[current_frag_data_start..data_len]);
+                            }
+
+                            // Decrypt final fragment (or only fragment if not fragmented)
                             let current_frag_data_start = data_len;
-                            data_len += f.len() - HEADER_SIZE;
+                            let last_fragment = fragments.last().unwrap().as_ref();
+                            if last_fragment.len() < (HEADER_SIZE + AES_GCM_TAG_SIZE) {
+                                return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+                            }
+                            data_len += last_fragment.len() - (HEADER_SIZE + AES_GCM_TAG_SIZE);
                             if data_len > data_buf.len() {
                                 return Err(ReceiveError::DataBufferTooSmall);
                             }
-                            c.decrypt(&f[HEADER_SIZE..], &mut data_buf[current_frag_data_start..data_len]);
-                        }
+                            let payload_end = last_fragment.len() - AES_GCM_TAG_SIZE;
+                            c.decrypt(&last_fragment[HEADER_SIZE..payload_end], &mut data_buf[current_frag_data_start..data_len]);
 
-                        // Decrypt final fragment (or only fragment if not fragmented)
-                        let current_frag_data_start = data_len;
-                        let last_fragment = fragments.last().unwrap().as_ref();
-                        if last_fragment.len() < (HEADER_SIZE + AES_GCM_TAG_SIZE) {
-                            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                        }
-                        data_len += last_fragment.len() - (HEADER_SIZE + AES_GCM_TAG_SIZE);
-                        if data_len > data_buf.len() {
-                            return Err(ReceiveError::DataBufferTooSmall);
-                        }
-                        let payload_end = last_fragment.len() - AES_GCM_TAG_SIZE;
-                        c.decrypt(&last_fragment[HEADER_SIZE..payload_end], &mut data_buf[current_frag_data_start..data_len]);
+                            let aead_authentication_ok = c.finish_decrypt(&last_fragment[payload_end..].try_into().unwrap());
+                            drop(c);
+                            drop(state);
 
-                        let aead_authentication_ok = c.finish_decrypt(&last_fragment[payload_end..].try_into().unwrap());
-                        drop(c);
-                        drop(state);
-
-                        if !aead_authentication_ok {
-                            return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                            if !aead_authentication_ok {
+                                return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
+                            }
+                            if !session.update_receive_window(incoming_counter) {
+                                // This can be naturally triggered because Bob has just
+                                // successfully received a session key and needs to reject
+                                // all of Alice's resends.
+                                // This can also occur naturally if some part of the outer
+                                // system is duplicating the packets being sent to us.
+                                // We are safely deduplicating them here.
+                                return Err(byzantine_fault!(FaultType::ExpiredCounter, true));
+                            }
+                            // Packet fully authenticated
+                            return Ok(ReceiveOk::Session(session, SessionEvent::Data(&mut data_buf[..data_len])));
                         }
-                        if !session.update_receive_window(incoming_counter) {
-                            // This can be naturally triggered because Bob has just
-                            // successfully received a session key and needs to reject
-                            // all of Alice's resends.
-                            // This can also occur naturally if some part of the outer
-                            // system is duplicating the packets being sent to us.
-                            // We are safely deduplicating them here.
-                            return Err(byzantine_fault!(FaultType::ExpiredCounter, true));
+                        PACKET_TYPE_HANDSHAKE_RESPONSE => {
+                            (Some(session), packet_type, fragments)
                         }
-                        // Packet fully authenticated
-                        return Ok(ReceiveResult::Session(session, SessionEvent::Data(&mut data_buf[..data_len])));
-                    } else if packet_type == PACKET_TYPE_NOISE_XK_PATTERN_2 {
-                        (Some(session), packet_type, fragments)
-                    } else {
-                        unreachable!()
                     }
                 } else {
                     drop(session_map);
                     // Check for and handle PACKET_TYPE_ALICE_NOISE_XK_PATTERN_3
-                    incoming = self.0.unassociated_handshake_states.get(local_key_id);
+                    incoming = self.0.unassociated_handshake_states.get(kid_recv);
                     if let Some(incoming) = incoming.as_ref() {
-                        Application::PrpDec::new(incoming.header_receive_key.as_ref()).decrypt_in_place(
-                            (&mut incoming_physical_packet[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END])
+                        App::PrpDec::new(&incoming.hk_recv).decrypt_in_place(
+                            (&mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
                                 .try_into()
                                 .unwrap(),
                         );
-                        let (fragment_count, fragment_no, packet_type, _, header_nonce) = parse_packet_header(incoming_physical_packet);
-                        app.event_log(
-                            LogEvent::ReceiveUnassociatedFragment(fragment_count, fragment_no, packet_type),
-                            current_time,
-                        );
-                        if packet_type != PACKET_TYPE_NOISE_XK_PATTERN_3 {
-                            return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+
+                        let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
+                        let (packet_type, incoming_counter) = from_nonce(&nonce);
+
+                        {//vrfy
+                            log!(app, ReceivedRawFragment(packet_type, incoming_counter, frag_no, frag_count));
+                            if packet_type != PACKET_TYPE_HANDSHAKE_COMPLETION || incoming_counter != 0 {
+                               return Err(byzantine_fault!(InvalidPacket, true))
+                            }
                         }
+
                         let fragments = if fragment_count > 1 {
-                            incoming.noise_pattern3_defrag.lock().unwrap().assemble(
-                                header_nonce,
-                                incoming_physical_packet_buf,
+                            incoming.defrag.lock().unwrap().assemble(
+                                &nonce,
+                                incoming_fragment_buf,
                                 fragment_no,
                                 fragment_count,
                                 &mut assembled_packet,
@@ -789,850 +373,59 @@ impl<Application: ApplicationLayer> Context<Application> {
                             if !assembled_packet.is_empty() {
                                 assembled_packet.as_ref()
                             } else {
-                                return Ok(ReceiveResult::Unassociated);
+                                return Ok(ReceiveOk::Unassociated);
                             }
                         } else {
-                            std::array::from_ref(&incoming_physical_packet_buf)
+                            std::slice::from_ref(&incoming_fragment_buf)
                         };
                         // We must guarantee that this incoming handshake is processed once and only
                         // once. This prevents catastrophic nonce reuse caused by multithreading.
-                        if self.0.unassociated_handshake_states.remove(local_key_id) {
-                            (None, PACKET_TYPE_NOISE_XK_PATTERN_3, fragments)
+                        if self.0.unassociated_handshake_states.remove(kid_recv) {
+                            (None, PACKET_TYPE_HANDSHAKE_COMPLETION, fragments)
                         } else {
-                            return Ok(ReceiveResult::Unassociated);
+                            return Ok(ReceiveOk::Unassociated);
                         }
                     } else {
                         // This can occur naturally because either Bob's incoming_sessions cache got
                         // full so Alice's incoming session was dropped, or the session this packet
                         // was for was dropped by the application.
-                        return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
+                        return Err(byzantine_fault!(UnknownLocalKeyId, true));
                     }
                 }
             } else {
-                let (fragment_count, fragment_no, packet_type, _, header_nonce) = parse_packet_header(incoming_physical_packet);
-                app.event_log(
-                    LogEvent::ReceiveUnassociatedFragment(fragment_count, fragment_no, packet_type),
-                    current_time,
-                );
-                if packet_type != PACKET_TYPE_NOISE_XK_PATTERN_1 && packet_type != PACKET_TYPE_BOB_DOS_CHALLENGE {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
+                let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
+                let (packet_type, incoming_counter) = from_nonce(&nonce);
+
+                {//vrfy
+                    log!(app, ReceivedRawFragment(packet_type, incoming_counter, frag_no, frag_count));
+                    if packet_type != PACKET_TYPE_HANDSHAKE_HELLO && packet_type != PACKET_TYPE_CHALLENGE {
+                        return Err(byzantine_fault!(InvalidPacket, true))
+                    }
                 }
+
                 let fragments = if fragment_count > 1 {
                     self.0.unassociated_defrag_cache.lock().unwrap().assemble(
-                        header_nonce,
+                        &nonce,
                         remote_address,
-                        incoming_physical_packet_len - HEADER_SIZE,
-                        incoming_physical_packet_buf,
+                        incoming_fragment.len() - HEADER_SIZE,
+                        incoming_fragment_buf,
                         fragment_no,
                         fragment_count,
-                        Application::RETRY_INTERVAL_MS,
+                        App::SETTINGS.resend_time as i64,
                         current_time,
                         &mut assembled_packet,
                     );
                     if !assembled_packet.is_empty() {
                         assembled_packet.as_ref()
                     } else {
-                        return Ok(ReceiveResult::Unassociated);
+                        return Ok(ReceiveOk::Unassociated);
                     }
                 } else {
-                    std::array::from_ref(&incoming_physical_packet_buf)
+                    std::array::from_ref(&incoming_fragment_buf)
                 };
                 (None, packet_type, fragments)
             }
         };
-
-        debug_assert!(!fragments.is_empty());
-        debug_assert!(incoming.is_none() || session.is_none());
-
-        let message = &mut [0u8; MAX_NOISE_HANDSHAKE_SIZE];
-        let message_size = assemble_fragments_into::<Application>(fragments, message)?;
-        if message_size < MIN_PACKET_SIZE {
-            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-        }
-
-        use OfferStateMachine::*;
-        match packet_type {
-            PACKET_TYPE_NOISE_XK_PATTERN_1 => {
-                // Alice (remote) --> Bob (local)
-                // -> e, es, e1
-                app.event_log(LogEvent::ReceiveUncheckedXK1, current_time);
-
-                if session.is_some() || incoming.is_some() {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-                if !(NoiseXKPattern1::MIN_SIZE..=NoiseXKPattern1::MAX_SIZE).contains(&message_size) {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                // The message id must be the first 8 bytes of the gcm tag.
-                // This forces the message id to be authenticated along with the entire message.
-                let p_auth_end = message_size - ChallengeResponse::SIZE;
-                if message[8..16] != message[p_auth_end - 8..p_auth_end] {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                let p_size = p_auth_end - NoiseXKPattern1::P_ENC_START - AES_GCM_TAG_SIZE;
-                let total_ratchet_fingerprints = p_size / RATCHET_SIZE;
-                if p_size % RATCHET_SIZE != 0 || total_ratchet_fingerprints > 2 {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-
-                let noise_pattern1: &NoiseXKPattern1 = byte_array_as_proto_buffer(message);
-                if let Some(remote_key_id) = NonZeroU32::new(u32::from_ne_bytes(noise_pattern1.alice_key_id)) {
-                    let sha512 = &mut Application::Hash::new();
-                    // Let application filter incoming connection attempts by whatever criteria it wants.
-                    // This should ideally prevent ZSSP from wasting time on DDOS attacks.
-                    match check_allow_incoming_session() {
-                        IncomingSessionAction::Allow => {}
-                        IncomingSessionAction::Challenge => {
-                            let response: &ChallengeResponse = byte_array_as_proto_buffer(&message[p_auth_end..message_size]);
-                            let counter = u64::from_be_bytes(response.challenge_counter.try_into().unwrap());
-
-                            sha512.reset();
-                            let mut hasher = ShaHasher(sha512);
-                            let mut output = [0u8; HASHLEN];
-                            hasher.0.update(&response.challenge_counter);
-                            remote_address.hash(&mut hasher);
-                            hasher.0.update(&self.0.challenge_salt);
-                            hasher.0.finish(&mut output);
-                            let is_valid = self.check_challenge_window(counter)
-                                && secure_eq(&output[..CHALLENGE_MAC_SIZE], &response.challenge_mac)
-                                && verify_pow::<Application>(hasher.0, &message[p_auth_end..message_size])
-                                && self.update_challenge_window(counter);
-                            app.event_log(LogEvent::ReceiveCheckXK1Challenge(is_valid), current_time);
-                            if !is_valid {
-                                // Alice failed the challenge so issue them a new challenge.
-                                let mut challenge_buffer = [0u8; BobDOSChallenge::SIZE];
-                                let challenge: &mut BobDOSChallenge = byte_array_as_proto_buffer_mut(&mut challenge_buffer);
-                                challenge.alice_key_id = remote_key_id.get().to_ne_bytes();
-                                // We attach a monotonically increasing counter value to the challenge
-                                // so it cannot be replayed.
-                                let counter = self.0.challenge_counter.fetch_add(1, Ordering::Relaxed);
-                                challenge.challenge_counter = counter.to_be_bytes();
-
-                                hasher.0.reset();
-                                hasher.0.update(&counter.to_be_bytes());
-                                remote_address.hash(&mut hasher);
-                                hasher.0.update(&self.0.challenge_salt);
-                                hasher.0.finish(&mut output);
-                                challenge.challenge_mac.copy_from_slice(&output[..CHALLENGE_MAC_SIZE]);
-                                challenge.prior_challenge_pow = response.challenge_pow;
-                                // We haven't decrypted any of Alice's packet so we don't know the
-                                // header protection cipher.
-                                // For DOS resistance Alice will not accept unencrypted headers directly
-                                // into their session defrag buffer, so we have to send them this reply
-                                // through their incoming sessions cache.
-                                send_with_fragmentation(
-                                    &mut send_unassociated_reply,
-                                    send_unassociated_mtu,
-                                    &mut challenge_buffer,
-                                    PACKET_TYPE_BOB_DOS_CHALLENGE,
-                                    None,
-                                    self.0.rng.lock().unwrap().next_u64(),
-                                    None::<&Application::PrpEnc>,
-                                );
-                                return Ok(ReceiveResult::Unassociated);
-                            }
-                            // Alice succeeded at the challenge so continue to decryption.
-                        }
-                        IncomingSessionAction::Drop => return Ok(ReceiveResult::Rejected),
-                    }
-
-                    // Noise process handshake prologue.
-                    let noise_h = mix_hash(
-                        sha512,
-                        &INITIAL_H,
-                        &message[NoiseXKPattern1::PROLOGUE_START..NoiseXKPattern1::PROLOGUE_END],
-                    );
-                    let noise_h = mix_hash(sha512, &noise_h, self.0.static_keypair.public_key_bytes());
-                    // Noise process pattern1 e token.
-                    let mut noise_ck = SymmetricState::new(INITIAL_H);
-                    let hmac = &mut Application::HmacHash::new();
-                    let mut noise_es = Secret::new();
-                    let noise_e_pattern1 = from_bytes_agreement::<Application>(&noise_pattern1.noise_e, &self.0.static_keypair, noise_es.as_mut())
-                        .ok_or(byzantine_fault!(FaultType::FailedAuthentication, false))?;
-                    let noise_h_e = mix_hash(sha512, &noise_h, &noise_pattern1.noise_e);
-                    noise_ck.mix_key(hmac, &noise_pattern1.noise_e);
-                    // Noise process pattern1 es token.
-                    let noise_k_es = noise_ck.mix_key_initialize_key(hmac, noise_es.as_ref());
-                    drop(noise_es);
-                    // Noise process pattern1 e1 token.
-                    let (is_auth, noise_h_ee1) = decrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_es,
-                        &noise_h_e,
-                        packet_type,
-                        0,
-                        &mut message[NoiseXKPattern1::E1_ENC_START..NoiseXKPattern1::P_ENC_START],
-                    );
-                    if !is_auth {
-                        // This could occur naturally if Alice's ApplicationLayer is dynamically
-                        // changing their mtu, which in bad network conditions could clobber their
-                        // resent KEX packet.
-                        // Or maybe Alice randomly generated the same temporary id twice in a row.
-                        // Since these situations are super unlikely to occur we still mark this error
-                        // as unnatural.
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    }
-                    // Noise process pattern1 payload.
-                    let (is_auth, noise_h_ee1p) = decrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_es,
-                        &noise_h_ee1,
-                        packet_type,
-                        1,
-                        &mut message[NoiseXKPattern1::P_ENC_START..p_auth_end],
-                    );
-                    drop(noise_k_es);
-                    if !is_auth {
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    }
-                    let (header_b2a_key, header_a2b_key) = noise_ck.get_ask2(hmac, LABEL_HEADER_KEY, &noise_h_ee1p);
-                    // Get ratchet key.
-                    let noise_pattern1: &NoiseXKPattern1 = byte_array_as_proto_buffer(message);
-                    let mut ratchet_state = RatchetState::Null;
-                    for i in 0..total_ratchet_fingerprints {
-                        match app.restore_by_fingerprint(
-                            (&noise_pattern1.payload[i * RATCHET_SIZE..(i + 1) * RATCHET_SIZE]).try_into().unwrap(),
-                            current_time,
-                        ) {
-                            Ok(RatchetState::Null) | Ok(RatchetState::Empty) => {}
-                            Ok(rs) => {
-                                ratchet_state = rs;
-                                break;
-                            }
-                            Err(e) => return Err(ReceiveError::RatchetIoError(e)),
-                        }
-                    }
-                    if ratchet_state.is_null() {
-                        if app.hello_requires_recognized_ratchet(current_time) {
-                            return Ok(ReceiveResult::Rejected);
-                        }
-                        ratchet_state = RatchetState::Empty;
-                    }
-
-                    // Start of Noise XKhfs+psk2 pattern2.
-                    let mut message2 = [0u8; NoiseXKPattern2::SIZE];
-                    let noise_pattern2: &mut NoiseXKPattern2 = byte_array_as_proto_buffer_mut(&mut message2);
-                    // Noise process pattern2 e token.
-                    let noise_e_pattern2_secret = Application::KeyPair::generate(&mut self.0.rng.lock().unwrap());
-                    noise_pattern2.noise_e = *noise_e_pattern2_secret.public_key_bytes();
-                    let noise_h_ee1pe = mix_hash(sha512, &noise_h_ee1p, &noise_pattern2.noise_e);
-                    noise_ck.mix_key(hmac, &noise_pattern2.noise_e);
-                    // Noise process pattern2 ee token.
-                    let mut noise_ee = Secret::new();
-                    if !noise_e_pattern2_secret.agree(&noise_e_pattern1, noise_ee.as_mut()) {
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    }
-                    let noise_k_esee = noise_ck.mix_key_initialize_key(hmac, noise_ee.as_ref());
-                    drop(noise_ee);
-                    // Noise process pattern2 ekem1 token.
-                    let (noise_ekem1, noise_ekem1_secret) = pqc_kyber::encapsulate(&noise_pattern1.noise_e1, self.0.rng.lock().unwrap().deref_mut())
-                        .map_err(|_| byzantine_fault!(FaultType::FailedAuthentication, false))
-                        .map(|(ct, ekem1)| (ct, Secret(ekem1)))?;
-                    // Alice fully authenticated.
-                    noise_pattern2.noise_ekem1 = noise_ekem1;
-                    let noise_h_ee1peekem1 = encrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_esee,
-                        &noise_h_ee1pe,
-                        PACKET_TYPE_NOISE_XK_PATTERN_2,
-                        0,
-                        &mut message2[NoiseXKPattern2::EKEM1_ENC_START..NoiseXKPattern2::P_ENC_START],
-                    );
-                    drop(noise_k_esee);
-                    noise_ck.mix_key(hmac, noise_ekem1_secret.as_ref());
-                    drop(noise_ekem1_secret);
-                    // Noise process pattern2 psk token.
-                    let ratchet_key = ratchet_state.key().unwrap();
-                    let (temp_h, noise_k_eseeekem1psk) = noise_ck.mix_key_and_hash_initialize_key(hmac, ratchet_key);
-                    let noise_h_ee1peekem1psk = mix_hash(sha512, &noise_h_ee1peekem1, &temp_h);
-                    // Noise process pattern2 payload.
-                    // We try to prevent the id we generate from colliding with another session but
-                    // because we might have handshakes in flight it's impossible to 100% prevent.
-                    // In those exceedingly rare cases we have to drop Alice's session and start over.
-                    let local_key_id = generate_key_id(&self.0.session_map.read().unwrap(), &mut self.0.rng.lock().unwrap());
-                    let noise_pattern2: &mut NoiseXKPattern2 = byte_array_as_proto_buffer_mut(&mut message2);
-                    noise_pattern2.bob_key_id = local_key_id.get().to_ne_bytes();
-
-                    let noise_h_ee1peekem1pskp = encrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_eseeekem1psk,
-                        &noise_h_ee1peekem1psk,
-                        PACKET_TYPE_NOISE_XK_PATTERN_2,
-                        0,
-                        &mut message2[NoiseXKPattern2::P_ENC_START..NoiseXKPattern2::P_AUTH_END],
-                    );
-
-                    app.event_log(LogEvent::ReceiveValidXK1, current_time);
-                    let handshake = Arc::new(NoiseXKBobHandshakeState {
-                        local_key_id,
-                        remote_key_id,
-                        ratchet_state,
-                        noise_h_ee1peekem1pskp,
-                        noise_ck_eseeekem1psk: noise_ck.clone(),
-                        noise_k_eseeekem1psk: noise_k_eseeekem1psk.clone(),
-                        noise_e_secret: noise_e_pattern2_secret,
-                        header_receive_key: header_a2b_key.clone(),
-                        header_send_key: header_b2a_key.clone(),
-                        noise_pattern3_defrag: Mutex::new(Fragged::new()),
-                    });
-                    self.0.unassociated_handshake_states.insert(local_key_id, handshake, current_time);
-
-                    // We put a copy of the gcm tag in the header so Alice can tell this packet apart
-                    // from any other pattern 1 packet we send, without having to make Bob maintain state.
-                    let mut pattern2_id = 0u64.to_ne_bytes();
-                    pattern2_id[5] = message2[NoiseXKPattern2::P_AUTH_END - 3];
-                    pattern2_id[6] = message2[NoiseXKPattern2::P_AUTH_END - 2];
-                    pattern2_id[7] = message2[NoiseXKPattern2::P_AUTH_END - 1];
-                    send_with_fragmentation(
-                        &mut send_unassociated_reply,
-                        send_unassociated_mtu,
-                        &mut message2,
-                        PACKET_TYPE_NOISE_XK_PATTERN_2,
-                        Some(remote_key_id),
-                        u64::from_be_bytes(pattern2_id),
-                        Some(&Application::PrpEnc::new(header_b2a_key.first_n::<AES_GCM_KEY_SIZE>())),
-                    );
-
-                    return Ok(ReceiveResult::Unassociated);
-                } else {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-            }
-            PACKET_TYPE_BOB_DOS_CHALLENGE => {
-                let message = &mut message[..message_size];
-                app.event_log(LogEvent::ReceiveUncheckedDOSChallenge, current_time);
-
-                // We expect Bob to only send this to us through our unassociated defrag cache.
-                if incoming.is_some() || session.is_some() {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-                if message.len() != BobDOSChallenge::SIZE {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                let challenge: &BobDOSChallenge = byte_array_as_proto_buffer(message);
-
-                if let Some(local_key_id) = NonZeroU32::new(u32::from_ne_bytes(challenge.alice_key_id)) {
-                    if let Some(session) = self.0.session_map.read().unwrap().get(&local_key_id).and_then(|s| s.0.upgrade()) {
-                        // We don't need to hold the kex lock because we are not transitioning state.
-                        let mut state = session.state.write().unwrap();
-                        if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
-                            if let NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, .. } = &mut handshake_state.offer {
-                                let response_raw = &mut noise_message[*noise_message_len - ChallengeResponse::SIZE..];
-
-                                let response: &mut ChallengeResponse = byte_array_as_proto_buffer_mut(response_raw);
-                                // Only people who know what Alice's prior pow was can convince us to
-                                // compute a new pow.
-                                if challenge.prior_challenge_pow != response.challenge_pow {
-                                    // This can occur if Bob sends us multiple challenges and they
-                                    // arrive OOO.
-                                    return Err(byzantine_fault!(FaultType::FailedAuthentication, true));
-                                }
-                                response.challenge_counter.copy_from_slice(&challenge.challenge_counter);
-                                response.challenge_mac.copy_from_slice(&challenge.challenge_mac);
-                                let mut pow = self.0.rng.lock().unwrap().next_u64();
-                                let sha512 = &mut Application::Hash::new();
-                                loop {
-                                    let response: &mut ChallengeResponse = byte_array_as_proto_buffer_mut(response_raw);
-                                    response.challenge_pow.copy_from_slice(&pow.to_be_bytes());
-                                    if verify_pow::<Application>(sha512, response_raw) {
-                                        break;
-                                    }
-                                    pow = pow.wrapping_add(1);
-                                }
-
-                                app.event_log(LogEvent::ReceiveValidDOSChallenge(&session), current_time);
-                                return Ok(ReceiveResult::Unassociated);
-                            } else {
-                                // This could happen if Bob challenges Alice, but their challenge packet
-                                // gets massively delayed.
-                                return Err(byzantine_fault!(FaultType::OutOfSequence, true));
-                            }
-                        } else {
-                            // This could happen if Bob challenges Alice, but their challenge packet
-                            // gets massively delayed.
-                            return Err(byzantine_fault!(FaultType::OutOfSequence, true));
-                        }
-                    } else {
-                        // This can occur naturally if Alice's session was dropped.
-                        return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
-                    }
-                } else {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-            }
-            PACKET_TYPE_NOISE_XK_PATTERN_2 => {
-                // Bob (remote) --> Alice (local)
-                // <- e, ee, ekem1, psk
-                let message = &mut message[..message_size];
-                app.event_log(LogEvent::ReceiveUncheckedXK2, current_time);
-
-                if incoming.is_some() {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-                if message.len() != NoiseXKPattern2::SIZE {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-
-                let session = session.ok_or(byzantine_fault!(FaultType::UnknownLocalKeyId, false))?;
-                let kex_lock = session.state_machine_lock.lock().unwrap();
-                let state = session.state.read().unwrap();
-
-                if let NoiseXKPattern1or3(handshake_state) = &state.outgoing_offer {
-                    if let NoiseXKAliceHandshakeState::NoiseXKPattern1 {
-                        noise_h_ee1p, noise_e_secret, noise_e1_secret, noise_ck_es, ..
-                    } = &handshake_state.offer
-                    {
-                        let noise_pattern2: &NoiseXKPattern2 = byte_array_as_proto_buffer(message);
-                        // Authenticate header counter.
-                        if noise_pattern2.header[13..16] != noise_pattern2.p_gcm_tag[13..16] {
-                            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                        }
-
-                        // Noise process pattern2 e token.
-                        let mut noise_ee = Secret::new();
-                        if let Some(noise_e_pattern2) =
-                            from_bytes_agreement::<Application>(&noise_pattern2.noise_e, noise_e_secret, noise_ee.as_mut())
-                        {
-                            let sha512 = &mut Application::Hash::new();
-                            let hmac = &mut Application::HmacHash::new();
-                            let mut noise_ck = noise_ck_es.clone();
-                            let noise_h_ee1pe = mix_hash(sha512, noise_h_ee1p, noise_e_pattern2.as_bytes());
-                            noise_ck.mix_key(hmac, noise_e_pattern2.as_bytes());
-                            // Noise process pattern2 ee token.
-                            let noise_k_esee = noise_ck.mix_key_initialize_key(hmac, noise_ee.as_ref());
-                            drop(noise_ee);
-                            // Noise process pattern2 ekem1 token.
-                            let (is_auth, noise_h_ee1peekem1) = decrypt_and_hash::<Application>(
-                                sha512,
-                                &noise_k_esee,
-                                &noise_h_ee1pe,
-                                packet_type,
-                                0,
-                                &mut message[NoiseXKPattern2::EKEM1_ENC_START..NoiseXKPattern2::P_ENC_START],
-                            );
-                            let noise_pattern2: &NoiseXKPattern2 = byte_array_as_proto_buffer(message);
-                            let noise_ekem1_secret = pqc_kyber::decapsulate(&noise_pattern2.noise_ekem1, noise_e1_secret.as_ref()).map(Secret);
-                            if let Some(Ok(noise_ekem1_secret)) = is_auth.then_some(noise_ekem1_secret) {
-                                noise_ck.mix_key(hmac, noise_ekem1_secret.as_ref());
-                                drop(noise_ekem1_secret);
-
-                                // We attempt to decrypt the payload at most three times. First two times with
-                                // the ratchet key Alice remembers, and final time with a ratchet
-                                // key of zero if Alice allows ratchet downgrades.
-                                // The following code is not constant time, meaning we leak to an
-                                // attacker whether or not we downgraded.
-                                // We don't currently consider this sensitive enough information to hide.
-                                let mut test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState, Secret<AES_GCM_KEY_SIZE>, [u8; 64])> {
-                                    // Check for which ratchet key Bob wants to use.
-                                    let mut noise_ck = noise_ck.clone();
-                                    let mut payload = [0u8; NoiseXKPattern2::P_AUTH_END - NoiseXKPattern2::P_ENC_START];
-                                    payload.copy_from_slice(&message[NoiseXKPattern2::P_ENC_START..NoiseXKPattern2::P_AUTH_END]);
-                                    // Noise process pattern2 psk token.
-                                    let (temp_h, noise_k_eseeekem1psk) = noise_ck.mix_key_and_hash_initialize_key(hmac, ratchet_key);
-                                    let noise_h_ee1peekem1psk = mix_hash(sha512, &noise_h_ee1peekem1, &temp_h);
-                                    // Noise process pattern2 payload.
-                                    let (is_auth, noise_h_ee1peekem1pskp) = decrypt_and_hash::<Application>(
-                                        sha512,
-                                        &noise_k_eseeekem1psk,
-                                        &noise_h_ee1peekem1psk,
-                                        packet_type,
-                                        0,
-                                        &mut payload,
-                                    );
-                                    if is_auth {
-                                        let key_id = NonZeroU32::new(u32::from_ne_bytes(
-                                            (&payload[..NoiseXKPattern2::P_AUTH_START - NoiseXKPattern2::P_ENC_START])
-                                                .try_into()
-                                                .unwrap(),
-                                        ));
-                                        key_id.map(|kid| (kid, noise_ck, noise_k_eseeekem1psk, noise_h_ee1peekem1pskp))
-                                    } else {
-                                        None
-                                    }
-                                };
-                                // Check first key.
-                                let mut ratchet_i = 0;
-                                let mut result = None;
-                                let mut chain_len = 0;
-                                if let Some(key) = state.ratchet_states[0].key() {
-                                    chain_len = state.ratchet_states[0].chain_len();
-                                    result = test_ratchet_key(key);
-                                }
-                                // Check second key.
-                                if result.is_none() {
-                                    ratchet_i = 1;
-                                    if let Some(key) = state.ratchet_states[1].key() {
-                                        chain_len = state.ratchet_states[1].chain_len();
-                                        result = test_ratchet_key(key);
-                                    }
-                                }
-                                // Check zero key.
-                                if result.is_none() && !app.initiator_disallows_downgrade(&session, current_time) {
-                                    chain_len = 0;
-                                    result = test_ratchet_key(&[0u8; RATCHET_SIZE]);
-                                    if result.is_some() {
-                                        // TODO: add some kind of warning callback or signal.
-                                    }
-                                }
-
-                                if let Some((remote_key_id, mut noise_ck, noise_k_eseeekem1psk, noise_h_ee1peekem1pskp)) = result {
-                                    // Start of Noise XKhfs+psk2 pattern3.
-                                    let mut message3 = [0u8; NoiseXKPattern3::MAX_SIZE];
-                                    // Noise process pattern3 s token.
-                                    let mut noise_se = Secret::new();
-                                    if self.0.static_keypair.agree(&noise_e_pattern2, noise_se.as_mut()) {
-                                        let payload = handshake_state.alice_identity_blob.as_ref();
-                                        // Packet fully authenticated.
-                                        let s_enc_start = HEADER_SIZE;
-                                        let s_auth_start = s_enc_start + P384_PUBLIC_KEY_SIZE;
-                                        let p_enc_start = s_auth_start + AES_GCM_TAG_SIZE;
-                                        let p_auth_start = p_enc_start + payload.len();
-                                        let p_auth_end = p_auth_start + AES_GCM_TAG_SIZE;
-                                        let message3_len = p_auth_end;
-
-                                        message3[s_enc_start..s_auth_start].copy_from_slice(self.0.static_keypair.public_key_bytes());
-                                        let noise_h_ee1peekem1pskps = encrypt_and_hash::<Application>(
-                                            sha512,
-                                            &noise_k_eseeekem1psk,
-                                            &noise_h_ee1peekem1pskp,
-                                            PACKET_TYPE_NOISE_XK_PATTERN_3,
-                                            1,
-                                            &mut message3[s_enc_start..p_enc_start],
-                                        );
-                                        drop(noise_k_eseeekem1psk);
-                                        // Noise process pattern3 se token.
-                                        let noise_k_eseeekem1pskse = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
-                                        drop(noise_se);
-                                        // Noise process pattern3 payload token.
-                                        message3[p_enc_start..p_auth_start].copy_from_slice(payload);
-                                        let noise_h_ee1peekem1pskpsp = encrypt_and_hash::<Application>(
-                                            sha512,
-                                            &noise_k_eseeekem1pskse,
-                                            &noise_h_ee1peekem1pskps,
-                                            PACKET_TYPE_NOISE_XK_PATTERN_3,
-                                            0,
-                                            &mut message3[p_enc_start..p_auth_end],
-                                        );
-                                        drop(noise_k_eseeekem1pskse);
-                                        // Alice finished Noise XKhfs+psk2 handshake.
-                                        // Transition offer state machine to the NoiseXKPattern3 state.
-                                        let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_ee1peekem1pskpsp);
-                                        let new_ratchet_state = RatchetState::new_nonempty(rk, rf, NonZeroU64::new(chain_len + 1).unwrap());
-
-                                        let ratchet_to_preserve = &state.ratchet_states[ratchet_i];
-                                        let result = app.save_ratchet_state(
-                                            &session.remote_static_key,
-                                            &session.application_data,
-                                            [&state.ratchet_states[0], &state.ratchet_states[1]],
-                                            [&new_ratchet_state, ratchet_to_preserve],
-                                            current_time,
-                                        );
-                                        if let Err(e) = result {
-                                            return Err(ReceiveError::RatchetIoError(e));
-                                        }
-
-                                        let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_ee1peekem1pskpsp);
-
-                                        let local_key_id = handshake_state.local_key_id;
-                                        drop(state);
-                                        let mut state = session.state.write().unwrap();
-                                        session
-                                            .kex_send_cipher
-                                            .lock()
-                                            .unwrap()
-                                            .replace(Application::AeadEnc::new(kex_key_a2b.as_ref()));
-                                        session
-                                            .kex_receive_cipher
-                                            .lock()
-                                            .unwrap()
-                                            .replace(Application::AeadDec::new(kex_key_b2a.as_ref()));
-                                        state.ratchet_states[1] = state.ratchet_states[ratchet_i].clone();
-                                        state.ratchet_states[0] = new_ratchet_state;
-
-                                        state.cipher_states[0].replace(SessionKey::new(
-                                            hmac,
-                                            noise_ck,
-                                            local_key_id,
-                                            remote_key_id,
-                                            INIT_COUNTER,
-                                            false,
-                                        ));
-                                        debug_assert!(state.cipher_states[1].is_none());
-                                        if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
-                                            handshake_state.next_retry_time =
-                                                AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS));
-                                            handshake_state.timeout = current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS);
-                                            handshake_state.offer = NoiseXKAliceHandshakeState::NoiseXKPattern3 {
-                                                noise_message: message3,
-                                                noise_message_len: p_auth_end,
-                                            };
-                                        }
-                                        drop(state);
-                                        drop(kex_lock);
-
-                                        if let Some((mut send, mut mtu)) = send_to(&session) {
-                                            mtu = mtu.max(MIN_TRANSPORT_MTU);
-                                            send_with_fragmentation(
-                                                &mut send,
-                                                mtu,
-                                                &mut message3[..message3_len],
-                                                PACKET_TYPE_NOISE_XK_PATTERN_3,
-                                                Some(remote_key_id),
-                                                0,
-                                                Some(&session.header_send_cipher),
-                                            );
-                                        }
-                                        app.event_log(LogEvent::ReceiveValidXK2(&session), current_time);
-                                        return Ok(ReceiveResult::Session(session, SessionEvent::Control));
-                                    }
-                                }
-                            }
-                        }
-                        // Bob failed authentication so we must restart our offer according to Noise.
-                        // We restart the offer instead of dropping the session to defend against DOS.
-                        drop(state);
-                        let mut state = session.state.write().unwrap();
-                        let ratchet_state = state.ratchet_states.clone();
-                        if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
-                            if !handshake_state.reinitialize(
-                                &session,
-                                &ratchet_state,
-                                &mut self.0.session_map.write().unwrap(),
-                                &mut self.0.rng.lock().unwrap(),
-                                current_time,
-                            ) {
-                                session.expire()
-                            }
-                        }
-                        drop(state);
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    } else {
-                        return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                    }
-                } else {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-            }
-            PACKET_TYPE_NOISE_XK_PATTERN_3 => {
-                // Alice (remote) --> Bob (local)
-                // -> s, se
-                let message = &mut message[..message_size];
-                app.event_log(LogEvent::ReceiveUncheckedXK3, current_time);
-
-                if session.is_some() {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-                if message.len() < NoiseXKPattern3::MIN_SIZE || message.len() > NoiseXKPattern3::MAX_SIZE {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                // The code above guarantees to us that each `incoming` handshake state that reaches
-                // this point will be strictly unique, even for the same remote peer.
-                // This property is strictly necessary to prevent catastrophic nonce reuse due to
-                // two session being created with the same set of keys.
-                let handshake_state = incoming.ok_or(byzantine_fault!(FaultType::UnknownLocalKeyId, false))?;
-                let s_enc_start = HEADER_SIZE;
-
-                let s_auth_start = s_enc_start + P384_PUBLIC_KEY_SIZE;
-                let p_enc_start = s_auth_start + AES_GCM_TAG_SIZE;
-                let p_auth_end = message.len();
-                let p_auth_start = p_auth_end - AES_GCM_TAG_SIZE;
-
-                if !(p_enc_start <= p_auth_start) {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                // Do not read from the message before this point, otherwise an array out of bounds
-                // error is possible.
-                // Noise process pattern3 s token.
-                let sha512 = &mut Application::Hash::new();
-                let hmac = &mut Application::HmacHash::new();
-                let (is_auth, noise_h_ee1peekem1pskps) = decrypt_and_hash::<Application>(
-                    sha512,
-                    &handshake_state.noise_k_eseeekem1psk,
-                    &handshake_state.noise_h_ee1peekem1pskp,
-                    packet_type,
-                    1,
-                    &mut message[s_enc_start..p_enc_start],
-                );
-                if !is_auth {
-                    return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                }
-                // Noise process pattern3 se token.
-                let mut noise_se = Secret::new();
-                if let Some(remote_s_public_key) =
-                    from_bytes_agreement::<Application>(&message[s_enc_start..s_auth_start], &handshake_state.noise_e_secret, noise_se.as_mut())
-                {
-                    let mut noise_ck = handshake_state.noise_ck_eseeekem1psk.clone();
-                    let noise_k_eseeekem1pskse = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
-                    drop(noise_se);
-                    // Noise process pattern3 payload.
-                    let (is_auth, noise_h_ee1peekem1pskpsp) = decrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_eseeekem1pskse,
-                        &noise_h_ee1peekem1pskps,
-                        packet_type,
-                        0,
-                        &mut message[p_enc_start..p_auth_end],
-                    );
-                    drop(noise_k_eseeekem1pskse);
-                    if !is_auth {
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    }
-                    // Bob finished Noise XKhfs+psk2 handshake.
-                    let header_send_cipher = Application::PrpEnc::new(handshake_state.header_send_key.as_ref());
-                    let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_ee1peekem1pskpsp);
-                    let mut send_reject = || {
-                        // We just used a counter with this key, but we are not storing
-                        // the fact we used it in memory. This is currently ok because the
-                        // handshake is being dropped, so nonce reuse can't happen.
-                        let (mut fragment, len) = encrypt_control(
-                            &mut Application::AeadEnc::new(kex_key_b2a.as_ref()),
-                            &header_send_cipher,
-                            PACKET_TYPE_SESSION_REJECTED,
-                            INIT_COUNTER,
-                            handshake_state.remote_key_id.get(),
-                            &[],
-                        );
-                        send_unassociated_reply(&mut fragment[..len]);
-                    };
-
-                    let (responder_disallows_downgrade, responder_silently_rejects) = check_accept_session(
-                        &remote_s_public_key,
-                        &message[p_enc_start..p_auth_start],
-                        handshake_state.ratchet_state.chain_len(),
-                    );
-                    if let Some((responder_disallows_downgrade, application_data)) = responder_disallows_downgrade {
-                        let result = app.restore_by_identity(&remote_s_public_key, &application_data, current_time);
-                        match result {
-                            Ok(true_ratchet_states) => {
-                                let mut has_match = false;
-                                for rs in &true_ratchet_states {
-                                    if !rs.is_null() {
-                                        has_match |= &handshake_state.ratchet_state == rs;
-                                    }
-                                }
-                                if !has_match {
-                                    if !responder_disallows_downgrade && handshake_state.ratchet_state.is_empty() {
-                                        // TODO: add some kind of warning callback or signal.
-                                    } else {
-                                        if !responder_silently_rejects {
-                                            send_reject();
-                                        }
-                                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                                    }
-                                }
-
-                                let mut noise_kk_ss = Secret::new();
-                                if !self.0.static_keypair.agree(&remote_s_public_key, noise_kk_ss.as_mut()) {
-                                    return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                                }
-                                let noise_kk_local_init_h = mix_hash(sha512, &INITIAL_H_REKEY, self.0.static_keypair.public_key_bytes());
-                                let noise_kk_local_init_h = mix_hash(sha512, &noise_kk_local_init_h, remote_s_public_key.as_bytes());
-                                let noise_kk_remote_init_h = mix_hash(sha512, &INITIAL_H_REKEY, remote_s_public_key.as_bytes());
-                                let noise_kk_remote_init_h = mix_hash(sha512, &noise_kk_remote_init_h, self.0.static_keypair.public_key_bytes());
-
-                                let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_ee1peekem1pskpsp);
-                                // We must make sure the ratchet key is saved before we transition.
-                                let new_ratchet_state =
-                                    RatchetState::new_nonempty(rk, rf, NonZeroU64::new(handshake_state.ratchet_state.chain_len() + 1).unwrap());
-                                let result = app.save_ratchet_state(
-                                    &remote_s_public_key,
-                                    &application_data,
-                                    [&true_ratchet_states[0], &true_ratchet_states[1]],
-                                    [&new_ratchet_state, &RatchetState::Null],
-                                    current_time,
-                                );
-                                if let Err(e) = result {
-                                    return Err(ReceiveError::RatchetIoError(e));
-                                }
-
-                                let mut session_queue = self.0.session_queue.lock().unwrap();
-                                let queue_idx = session_queue.reserve_index();
-                                let session = Arc::new(Session {
-                                    context: Arc::downgrade(&self.0),
-                                    queue_idx,
-                                    application_data,
-                                    remote_static_key: remote_s_public_key,
-                                    send_counter: AtomicU64::new(INIT_COUNTER),
-                                    session_has_expired: AtomicBool::new(false),
-                                    counter_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
-                                    state_machine_lock: Mutex::new(()),
-                                    state: RwLock::new(SessionMutableState {
-                                        ratchet_states: [new_ratchet_state.clone(), RatchetState::Null],
-                                        cipher_states: [
-                                            Some(SessionKey::new(
-                                                hmac,
-                                                noise_ck,
-                                                handshake_state.local_key_id,
-                                                handshake_state.remote_key_id,
-                                                INIT_COUNTER,
-                                                true,
-                                            )),
-                                            None,
-                                        ],
-                                        current_key: 0,
-                                        outgoing_offer: KeyConfirm {
-                                            next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-                                            timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
-                                        },
-                                    }),
-                                    header_receive_cipher: Application::PrpDec::new(handshake_state.header_receive_key.as_ref()),
-                                    header_send_cipher,
-                                    kex_send_cipher: Mutex::new(Some(Application::AeadEnc::new(kex_key_b2a.as_ref()))),
-                                    kex_receive_cipher: Mutex::new(Some(Application::AeadDec::new(kex_key_a2b.as_ref()))),
-                                    noise_kk_ss,
-                                    noise_kk_local_init_h,
-                                    noise_kk_remote_init_h,
-                                    defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
-                                    was_bob: true,
-                                });
-                                let timer = Reverse(current_time.saturating_add(Application::RETRY_INTERVAL_MS));
-                                session_queue.push_reserved(queue_idx, Arc::downgrade(&session), timer);
-                                drop(session_queue);
-                                // There is the miniscule possibility this key id is already
-                                // in use, in which case we have to drop this session like
-                                // nothing ever happened.
-                                let mut session_map = self.0.session_map.write().unwrap();
-                                if let std::collections::hash_map::Entry::Vacant(e) = session_map.entry(handshake_state.local_key_id) {
-                                    e.insert((Arc::downgrade(&session), false));
-                                    drop(session_map);
-                                    let _ =
-                                        session.send_control(&session.state.read().unwrap(), send_unassociated_reply, PACKET_TYPE_KEY_CONFIRM, &[]);
-
-                                    app.event_log(LogEvent::ReceiveValidXK3(&session.application_data), current_time);
-                                    return Ok(ReceiveResult::Session(session, SessionEvent::NewSession));
-                                } else {
-                                    // This can occur if we accidentally generate a key id collision.
-                                    // There is an extremely short amount of time during which
-                                    // another session can steal this session's id, we'll have to
-                                    // restart the handshake in this case.
-                                    return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
-                                }
-                            }
-                            Err(e) => {
-                                return Err(ReceiveError::RatchetIoError(e));
-                            }
-                        }
-                    } else {
-                        if !responder_silently_rejects {
-                            send_reject();
-                        }
-                        return Ok(ReceiveResult::Rejected);
-                    }
-                } else {
-                    return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                }
-            }
-            _ => return Err(byzantine_fault!(FaultType::InvalidPacket, false)),
-        }
-    }
-    /// Helper function for sending the empty string over the session. Useful for keep-alives.
-    ///
-    /// * `session` - The session to send to
-    /// * `send` - Function to call to send physical packet(s); the buffer passed to `send` is a
-    ///   slice of `data`
-    /// * `current_time` - Current time in milliseconds
-    pub fn send_empty(&self, session: &Arc<Session<Application>>, send: impl FnMut(&mut [u8]) -> bool, current_time: i64) -> Result<(), SendError> {
-        self.send(session, send, &mut [0u8; MIN_TRANSPORT_MTU], &[], current_time)
     }
     /// Send data over the session.
     ///
@@ -1644,7 +437,7 @@ impl<Application: ApplicationLayer> Context<Application> {
     /// * `current_time` - Current time in milliseconds
     pub fn send(
         &self,
-        session: &Arc<Session<Application>>,
+        session: &Arc<Session<App>>,
         mut send: impl FnMut(&mut [u8]) -> bool,
         mtu_sized_buffer: &mut [u8],
         mut data: &[u8],
@@ -1710,983 +503,229 @@ impl<Application: ApplicationLayer> Context<Application> {
         }
         Ok(())
     }
-    /// Update the challenge window, returning true if the challenge is still valid.
-    fn check_challenge_window(&self, counter: u64) -> bool {
-        let slot = &self.0.challenge_antireplay_window[(counter as usize) % self.0.challenge_antireplay_window.len()];
-        let counter = counter.wrapping_add(1);
-        let prev_counter = slot.load(Ordering::Relaxed);
-        prev_counter < counter
-    }
-    /// Update the challenge window, returning true if the challenge is still valid.
-    fn update_challenge_window(&self, counter: u64) -> bool {
-        let slot = &self.0.challenge_antireplay_window[(counter as usize) % self.0.challenge_antireplay_window.len()];
-        let counter = counter.wrapping_add(1);
-        let prev_counter = slot.fetch_max(counter, Ordering::Relaxed);
-        prev_counter < counter
-    }
-}
-/// Initiate the rekeying protocol. This session will now begin attempting to rekey this session
-/// with its peer, if it was not already.
-fn initiate_rekey<Application: ApplicationLayer>(
-    context: &Arc<ContextInner<Application>>,
-    session: &Arc<Session<Application>>,
-    send: impl FnOnce(&mut [u8]) -> bool,
-    current_time: i64,
-) -> Result<i64, ()> {
-    let mut message = [0u8; NoiseKKPattern1or2::SIZE];
 
-    let kex_lock = session.state_machine_lock.lock().unwrap();
-    let state = session.state.read().unwrap();
-    // We may only attempt to rekey if we are not already doing so.
-    match &state.outgoing_offer {
-        OfferStateMachine::Normal { .. } => (),
-        _ => return Err(()),
-    }
-    let sha512 = &mut Application::Hash::new();
-    let hmac = &mut Application::HmacHash::new();
-    // Start of Noise KKpsk0 pattern1.
-    // Noise process pattern1 psk0 token.
-    let mut noise_ck = SymmetricState::new(INITIAL_H_REKEY);
-    let noise_temp_h = noise_ck.mix_key_and_hash(hmac, state.ratchet_states[0].key().unwrap());
-    let noise_h_psk = mix_hash(sha512, &session.noise_kk_local_init_h, &noise_temp_h);
-    // Noise process pattern1 e token.
-    let noise_e_secret = Application::KeyPair::generate(&mut context.rng.lock().unwrap());
-    let noise_h_pske = mix_hash(sha512, &noise_h_psk, noise_e_secret.public_key_bytes());
-    noise_ck.mix_key(hmac, noise_e_secret.public_key_bytes());
+    /// Perform periodic background service and cleanup tasks.
+    ///
+    /// This returns the number of milliseconds until it should be called again. The caller should
+    /// try to satisfy this but small variations in timing of up to +/- a second or two are not
+    /// a problem.
+    ///
+    /// * `send_to` - Function to get a sender and an MTU to send something over an active session
+    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
+    ///   with remote peers (although both of these properties would help reliability slightly).
+    ///   Used to determine if any current handshakes should be resent or timed-out, or if a session
+    ///   should rekey.
+    pub fn service<SendFn: FnMut(&mut [u8]) -> bool>(
+        &self,
+        app: &App,
+        mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
+        current_time: i64,
+    ) -> i64 {
+        let retry_next = current_time.saturating_add(App::RETRY_INTERVAL_MS);
+        let mut next_service_time = 2 * App::RETRY_INTERVAL_MS;
 
-    let noise_pattern1: &mut NoiseKKPattern1or2 = byte_array_as_proto_buffer_mut(&mut message);
-    noise_pattern1.noise_e = *noise_e_secret.public_key_bytes();
-    // Noise process pattern1 es token.
-    let mut noise_es = Secret::new();
-    if !noise_e_secret.agree(&session.remote_static_key, noise_es.as_mut()) {
-        return Err(());
-    }
-    noise_ck.mix_key(hmac, noise_es.as_ref());
-    drop(noise_es);
-    // Noise process pattern1 ss token.
-    let noise_k_pskesss = noise_ck.mix_key_initialize_key(hmac, session.noise_kk_ss.as_ref());
-    // Noise process pattern1 payload token.
-    let mut session_map = context.session_map.write().unwrap();
-    let new_key_id = generate_key_id(&session_map, &mut context.rng.lock().unwrap());
-    let next_key_index = state.current_key ^ 1;
-    session_map.insert(new_key_id, (Arc::downgrade(session), next_key_index > 0));
-    drop(session_map);
-
-    let noise_pattern1: &mut NoiseKKPattern1or2 = byte_array_as_proto_buffer_mut(&mut message);
-    noise_pattern1.key_id = new_key_id.get().to_ne_bytes();
-    let noise_h_pskep = encrypt_and_hash::<Application>(
-        sha512,
-        &noise_k_pskesss,
-        &noise_h_pske,
-        PACKET_TYPE_NOISE_KK_PATTERN_1,
-        0,
-        &mut message[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
-    );
-    drop(noise_k_pskesss);
-
-    drop(state);
-    let mut state = session.state.write().unwrap();
-    state.outgoing_offer = OfferStateMachine::NoiseKKPattern1 {
-        next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-        timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
-        new_key_id,
-        noise_e_secret,
-        noise_message: message.clone(),
-        noise_h_pskep,
-        noise_ck: noise_ck.clone(),
-    };
-    drop(state);
-    drop(kex_lock);
-    let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_NOISE_KK_PATTERN_1, &message);
-    Ok(current_time.saturating_add(Application::RETRY_INTERVAL_MS))
-}
-fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mut [u8]) -> bool>(
-    context: &Context<Application>,
-    session: Arc<Session<Application>>,
-    app: &Application,
-    mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
-    packet_type: u8,
-    counter: u64,
-    fragment: &mut [u8],
-    current_time: i64,
-) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::StorageError>> {
-    let kex_lock = session.state_machine_lock.lock().unwrap();
-    let state = session.state.read().unwrap();
-    let mut c = session.kex_receive_cipher.lock().unwrap();
-    let message = decrypt_control(
-        c.as_mut().ok_or(byzantine_fault!(FaultType::OutOfSequence, false))?,
-        packet_type,
-        counter,
-        fragment,
-    )?;
-    drop(c);
-    session.update_receive_window(counter);
-    use OfferStateMachine::*;
-    return match packet_type {
-        PACKET_TYPE_SESSION_REJECTED => {
-            if let NoiseXKPattern1or3(_) = &state.outgoing_offer {
-                drop(state);
-                let mut state = session.state.write().unwrap();
-                state.outgoing_offer = OfferStateMachine::Null;
-                drop(state);
-                drop(kex_lock);
-                Ok(ReceiveResult::Session(session, SessionEvent::Rejected))
-            } else {
-                // This can occur naturally because of control packet resends.
-                Err(byzantine_fault!(FaultType::OutOfSequence, true))
+        let mut session_queue = self.0.session_queue.lock().unwrap();
+        // This update system takes heavy advantage of the fact that sessions only need to be updated
+        // either roughly every second or roughly every hour. That big gap allows for minor optimizations.
+        // If the gap changes (unlikely) this code may need to be rewritten.
+        while let Some((session, timer, queue_idx)) = session_queue.peek() {
+            if timer.0 >= current_time {
+                next_service_time = next_service_time.min(timer.0 - current_time);
+                break;
             }
-        }
-        PACKET_TYPE_KEY_CONFIRM => {
-            drop(state);
-            app.event_log(LogEvent::ReceiveValidKeyConfirm(&session), current_time);
-            let mut state = session.state.write().unwrap();
-            // We only want to stop sending NoiseKKPattern2 offers when the latest derived
-            // key is confirmed. And we only want to do that once.
-            let (used_latest_key, try_delete, ret) = match &state.outgoing_offer {
-                NoiseKKPattern2 { .. } => (true, true, SessionEvent::Control),
-                NoiseXKPattern1or3(handshake_state) => {
-                    if let NoiseXKAliceHandshakeState::NoiseXKPattern3 { .. } = &handshake_state.offer {
-                        (true, true, SessionEvent::Established)
-                    } else {
-                        (false, false, SessionEvent::Control)
-                    }
+            let session = match session.upgrade() {
+                Some(s) => s,
+                _ => {
+                    session_queue.remove(queue_idx);
+                    continue;
                 }
-                Null => (false, false, SessionEvent::Control),
-                _ => (true, false, SessionEvent::Control),
             };
-            if try_delete {
-                let result = if !state.ratchet_states[1].is_null() {
-                    app.save_ratchet_state(
-                        &session.remote_static_key,
-                        &session.application_data,
-                        [&state.ratchet_states[0], &state.ratchet_states[1]],
-                        [&state.ratchet_states[0], &RatchetState::Null],
-                        current_time,
-                    )
-                } else {
-                    Ok(())
-                };
-                if let Err(e) = result {
-                    return Err(ReceiveError::RatchetIoError(e));
-                }
-                if let NoiseKKPattern2 { kex_send_key, .. } = &state.outgoing_offer {
-                    session
-                        .kex_send_cipher
-                        .lock()
-                        .unwrap()
-                        .replace(Application::AeadEnc::new(kex_send_key.as_ref()));
-                }
-                state.ratchet_states[1] = RatchetState::Null;
-                state.current_key ^= 1;
-                state.outgoing_offer = new_normal_state(context.0.rng.lock().unwrap().next_u64(), current_time);
-            }
-            drop(state);
-            drop(kex_lock);
-            if used_latest_key {
-                if let Some((send, _)) = send_to(&session) {
-                    let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_ACK, &[]);
-                }
-            }
-            Ok(ReceiveResult::Session(session, ret))
-        }
-        PACKET_TYPE_ACK => {
-            if let KeyConfirm { .. } = &state.outgoing_offer {
-                drop(state);
-                app.event_log(LogEvent::ReceiveValidAck(&session), current_time);
-                let mut state = session.state.write().unwrap();
-                // Check if we should end any current offers and transition back to Normal state
-                state.outgoing_offer = new_normal_state(context.0.rng.lock().unwrap().next_u64(), current_time);
-                drop(kex_lock);
-                drop(state);
-                Ok(ReceiveResult::Session(session, SessionEvent::Control))
-            } else {
-                // This can occur naturally because of control packet resends.
-                Err(byzantine_fault!(FaultType::OutOfSequence, true))
-            }
-        }
-        PACKET_TYPE_NOISE_KK_PATTERN_1 => {
-            app.event_log(LogEvent::ReceiveUncheckedKK1, current_time);
-            let message = &mut message[..NoiseKKPattern1or2::SIZE];
-            let noise_pattern1: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
-            // We need the following operation to be atomic with the change of offer type
-            let (should_rekey_as_bob, chosen_id) = match &state.outgoing_offer {
-                // Check rekey rate limits.
-                Normal { .. } => (true, None),
-                // In the following situation, both parties are in state NoiseKKPattern1,
-                // we need to deterministically allow only one of them to transition to
-                // NoiseKKPattern2.
-                NoiseKKPattern1 { new_key_id, .. } => (session.was_bob, Some(*new_key_id)),
-                _ => (false, None),
-            };
-            if !should_rekey_as_bob {
-                // This can be triggered if both parties attempt rekeying simultaneously, or if the
-                // remote party sent us a duplicate rekey request.
-                // The code above handles this case and only lets one party through to rekeying.
-                drop(state);
-                drop(kex_lock);
-                return Ok(ReceiveResult::Session(session, SessionEvent::Control));
-            }
-            // Noise process pattern1 psk0 token.
-            let sha512 = &mut Application::Hash::new();
-            let hmac = &mut Application::HmacHash::new();
-            let mut noise_ck = SymmetricState::new(INITIAL_H_REKEY);
-            let noise_temp_h = noise_ck.mix_key_and_hash(hmac, state.ratchet_states[0].key().unwrap());
-            let noise_h_psk = mix_hash(sha512, &session.noise_kk_remote_init_h, &noise_temp_h);
-            // Noise process pattern1 e token.
-            // Get public key validation out of the way early
-            let mut noise_es = Secret::new();
-            let mut noise_ee = Secret::new();
-            let mut noise_se = Secret::new();
-            if let Some(alice_e) = from_bytes_agreement::<Application>(&noise_pattern1.noise_e, &context.0.static_keypair, noise_es.as_mut()) {
-                let bob_e_secret = Application::KeyPair::generate(&mut context.0.rng.lock().unwrap());
-                if bob_e_secret.agree(&alice_e, noise_ee.as_mut()) && bob_e_secret.agree(&session.remote_static_key, noise_se.as_mut()) {
-                    let noise_h_pske = mix_hash(sha512, &noise_h_psk, alice_e.as_bytes());
-                    noise_ck.mix_key(hmac, alice_e.as_bytes());
-                    // Noise process pattern1 es token.
-                    noise_ck.mix_key(hmac, noise_es.as_ref());
-                    drop(noise_es);
-                    // Noise process pattern1 ss token.
-                    let noise_k_pskesss = noise_ck.mix_key_initialize_key(hmac, session.noise_kk_ss.as_ref());
-
-                    // Noise process pattern1 payload.
-                    let (is_auth, noise_h_pskep) = decrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_pskesss,
-                        &noise_h_pske,
-                        packet_type,
-                        0,
-                        &mut message[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
-                    );
-                    let noise_pattern1: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
-                    if let (true, Some(remote_key_id)) = (is_auth, NonZeroU32::new(u32::from_ne_bytes(noise_pattern1.key_id))) {
-                        // Alice fully authenticated.
-                        // Start of Noise KKpsk0 pattern2.
-                        // Noise process pattern2 e token.
-                        let noise_h_pskepe = mix_hash(sha512, &noise_h_pskep, bob_e_secret.public_key_bytes());
-                        noise_ck.mix_key(hmac, bob_e_secret.public_key_bytes());
-                        // Noise process pattern2 ee token.
-                        noise_ck.mix_key(hmac, noise_ee.as_ref());
-                        drop(noise_ee);
-                        // Noise process pattern2 se token.
-                        let noise_k_pskessseese = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
-                        drop(noise_se);
-                        // Noise process pattern2 payload.
-                        let mut message2 = [0u8; NoiseKKPattern1or2::SIZE];
-                        let noise_pattern2: &mut NoiseKKPattern1or2 = byte_array_as_proto_buffer_mut(&mut message2);
-                        noise_pattern2.noise_e = *bob_e_secret.public_key_bytes();
-                        let mut session_map = context.0.session_map.write().unwrap();
-                        // If we already generated a new key id mapping reuse it.
-                        let new_key_id = chosen_id.unwrap_or_else(|| generate_key_id(&session_map, &mut context.0.rng.lock().unwrap()));
-                        noise_pattern2.key_id = new_key_id.get().to_ne_bytes();
-
-                        let noise_h_pskepep = encrypt_and_hash::<Application>(
-                            sha512,
-                            &noise_k_pskessseese,
-                            &noise_h_pskepe,
-                            PACKET_TYPE_NOISE_KK_PATTERN_2,
-                            0,
-                            &mut message2[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
-                        );
-                        drop(noise_k_pskessseese);
-                        // Bob finished Noise KKpsk0 handshake.
-                        let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_pskepep);
-                        let new_ratchet_state = RatchetState::new_nonempty(rk, rf, NonZeroU64::new(state.ratchet_states[0].chain_len() + 1).unwrap());
-                        let result = app.save_ratchet_state(
-                            &session.remote_static_key,
-                            &session.application_data,
-                            [&state.ratchet_states[0], &state.ratchet_states[1]],
-                            [&new_ratchet_state, &state.ratchet_states[0]],
-                            current_time,
-                        );
-                        if let Err(e) = result {
-                            drop(state);
-                            drop(kex_lock);
-                            return Err(ReceiveError::RatchetIoError(e));
-                        }
-                        let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_pskepep);
-                        // The new "Bob" doesn't know yet if Alice has received the new key, so the
-                        // new key is recorded as the "alt" (key_index ^ 1) but the current key is
-                        // not advanced yet.
-                        let next_key_index = state.current_key ^ 1;
-                        session_map.insert(new_key_id, (Arc::downgrade(&session), next_key_index > 0));
-                        if let Some(pre_id) = state.cipher_states[next_key_index].as_ref().map(|k| k.local_key_id) {
-                            session_map.remove(&pre_id);
-                        }
-                        drop(session_map);
+            let state = session.state.read().unwrap();
+            let next_timer = match &state.outgoing_offer {
+                Normal { timeout, .. } => {
+                    if *timeout <= current_time {
                         drop(state);
-                        let mut state = session.state.write().unwrap();
-                        let current_counter = session.send_counter.load(Ordering::Relaxed);
-                        session
-                            .kex_receive_cipher
-                            .lock()
-                            .unwrap()
-                            .replace(Application::AeadDec::new(kex_key_a2b.as_ref()));
-                        state.ratchet_states[1] = state.ratchet_states[0].clone();
-                        state.ratchet_states[0] = new_ratchet_state.clone();
-
-                        state.cipher_states[next_key_index].replace(SessionKey::new(
-                            hmac,
-                            noise_ck,
-                            new_key_id,
-                            remote_key_id,
-                            current_counter,
-                            true,
-                        ));
-                        let timer = current_time.saturating_add(Application::RETRY_INTERVAL_MS);
-                        state.outgoing_offer = NoiseKKPattern2 {
-                            next_retry_time: AtomicI64::new(timer),
-                            timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
-                            noise_message: message2,
-                            kex_send_key: kex_key_b2a.clone(),
-                        };
-                        drop(state);
-                        drop(kex_lock);
-                        context.0.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timer));
-
                         if let Some((send, _)) = send_to(&session) {
-                            let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_NOISE_KK_PATTERN_2, &message2);
+                            let result = initiate_rekey(&self.0, &session, send, current_time);
+                            if result.is_ok() {
+                                app.event_log(LogEvent::ServiceKKStart(&session), current_time);
+                            }
+                            result.unwrap_or(retry_next)
+                        } else {
+                            retry_next
                         }
-                        app.event_log(LogEvent::ReceiveValidKK1(&session), current_time);
-                        return Ok(ReceiveResult::Session(session, SessionEvent::Control));
+                    } else {
+                        *timeout
                     }
                 }
-            }
-            Err(byzantine_fault!(FaultType::FailedAuthentication, false))
-        }
-        PACKET_TYPE_NOISE_KK_PATTERN_2 => {
-            app.event_log(LogEvent::ReceiveUncheckedKK2, current_time);
-            let message = &mut message[..NoiseKKPattern1or2::SIZE];
-            let noise_pattern2: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
-
-            if let NoiseKKPattern1 { new_key_id, noise_e_secret, noise_ck, noise_h_pskep, .. } = &state.outgoing_offer {
-                // Noise process pattern2 e token.
-                let mut noise_ee = Secret::new();
-                let mut noise_se = Secret::new();
-                if let Some(bob_e) = from_bytes_agreement::<Application>(&noise_pattern2.noise_e, noise_e_secret, noise_ee.as_mut()) {
-                    if context.0.static_keypair.agree(&bob_e, noise_se.as_mut()) {
-                        let sha512 = &mut Application::Hash::new();
-                        let hmac = &mut Application::HmacHash::new();
-                        let mut noise_ck = noise_ck.clone();
-                        let noise_h_pskepe = mix_hash(sha512, noise_h_pskep, bob_e.as_bytes());
-                        noise_ck.mix_key(hmac, bob_e.as_bytes());
-                        // Noise process pattern2 ee token.
-                        noise_ck.mix_key(hmac, noise_ee.as_ref());
-                        drop(noise_ee);
-                        // Noise process pattern2 se token.
-                        let noise_k_pskessseese = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
-                        drop(noise_se);
-                        // Noise process pattern2 payload.
-                        let (is_auth, noise_h_pskepep) = decrypt_and_hash::<Application>(
-                            sha512,
-                            &noise_k_pskessseese,
-                            &noise_h_pskepe,
-                            packet_type,
-                            0,
-                            &mut message[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
-                        );
-                        let noise_pattern2: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
-                        if let (true, Some(remote_key_id)) = (is_auth, NonZeroU32::new(u32::from_ne_bytes(noise_pattern2.key_id))) {
-                            // Bob fully authenticated.
-                            // Alice finished Noise KKpsk0 handshake.
-                            let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_pskepep);
-                            let new_ratchet_state =
-                                RatchetState::new_nonempty(rk, rf, NonZeroU64::new(state.ratchet_states[0].chain_len() + 1).unwrap());
-                            let result = app.save_ratchet_state(
-                                &session.remote_static_key,
-                                &session.application_data,
-                                [&state.ratchet_states[0], &state.ratchet_states[1]],
-                                [&new_ratchet_state, &RatchetState::Null],
-                                current_time,
-                            );
-                            if let Err(e) = result {
-                                drop(state);
-                                drop(kex_lock);
-                                return Err(ReceiveError::RatchetIoError(e));
-                            }
-                            let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_pskepep);
-
-                            let new_key_id = *new_key_id;
+                // If there's an outstanding attempt to open a session, retransmit this
+                // periodically in case the initial packet doesn't make it.
+                NoiseXKPattern1or3(handshake_state) => {
+                    if let Some(ts) = process_timer(&handshake_state.next_retry_time, App::RETRY_INTERVAL_MS, current_time) {
+                        ts
+                    } else {
+                        // We have to eventually time out NoiseXKPattern3 because of unreliable network conditions.
+                        if handshake_state.timeout <= current_time {
                             drop(state);
+                            let _kex_lock = session.state_machine_lock.lock().unwrap();
                             let mut state = session.state.write().unwrap();
-                            let next_key_index = state.current_key ^ 1;
-                            state.current_key = next_key_index;
-                            if let Some(key) = state.cipher_states[next_key_index].as_ref() {
-                                context.0.session_map.write().unwrap().remove(&key.local_key_id);
+                            let ratchet_state = state.ratchet_states.clone();
+                            // Since we dropped the lock we must re-check if we are in the correct state.
+                            if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
+                                if handshake_state.timeout <= current_time {
+                                    app.event_log(LogEvent::ServiceXKTimeout(&session), current_time);
+                                    handshake_state.reinitialize(
+                                        &session,
+                                        &ratchet_state,
+                                        &mut self.0.session_map.write().unwrap(),
+                                        &mut self.0.rng.lock().unwrap(),
+                                        current_time,
+                                    );
+                                }
                             }
-                            session
-                                .kex_receive_cipher
-                                .lock()
-                                .unwrap()
-                                .replace(Application::AeadDec::new(kex_key_b2a.as_ref()));
-                            session
-                                .kex_send_cipher
-                                .lock()
-                                .unwrap()
-                                .replace(Application::AeadEnc::new(kex_key_a2b.as_ref()));
-                            state.ratchet_states[1] = RatchetState::Null;
-                            state.ratchet_states[0] = new_ratchet_state.clone();
-
-                            state.cipher_states[next_key_index].replace(SessionKey::new(
-                                hmac,
-                                noise_ck,
-                                new_key_id,
-                                remote_key_id,
-                                session.send_counter.load(Ordering::Relaxed),
-                                false,
-                            ));
-                            state.outgoing_offer = KeyConfirm {
-                                next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-                                timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
-                            };
-                            drop(state);
-                            drop(kex_lock);
-                            // Let Bob know we got the key.
-                            if let Some((send, _)) = send_to(&session) {
-                                let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_KEY_CONFIRM, &[]);
+                        } else if let Some((mut send, mut mtu)) = send_to(&session) {
+                            mtu = mtu.max(MIN_TRANSPORT_MTU);
+                            match &handshake_state.offer {
+                                NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, message_id, .. } => {
+                                    app.event_log(LogEvent::ServiceXK1Resend(&session), current_time);
+                                    // We are in state NoiseXKPattern1 so resend noise_pattern1.
+                                    send_with_fragmentation(
+                                        &mut send,
+                                        mtu,
+                                        &mut noise_message.clone()[..*noise_message_len],
+                                        PACKET_TYPE_NOISE_XK_PATTERN_1,
+                                        None,
+                                        *message_id,
+                                        None::<&App::PrpEnc>,
+                                    );
+                                }
+                                NoiseXKAliceHandshakeState::NoiseXKPattern3 { noise_message, noise_message_len, .. } => {
+                                    app.event_log(LogEvent::ServiceXK3Resend(&session), current_time);
+                                    send_with_fragmentation(
+                                        &mut send,
+                                        mtu,
+                                        &mut noise_message.clone()[..*noise_message_len],
+                                        PACKET_TYPE_NOISE_XK_PATTERN_3,
+                                        state.cipher_states[0].as_ref().map(|k| k.remote_key_id),
+                                        0,
+                                        Some(&session.header_send_cipher),
+                                    );
+                                }
                             }
-                            app.event_log(LogEvent::ReceiveValidKK2(&session), current_time);
-                            return Ok(ReceiveResult::Session(session, SessionEvent::Control));
                         }
+                        retry_next
                     }
                 }
-                // Bob failed authentication so according to Noise we must terminate this
-                // handshake.
-                // This should not happen in practice since this packet will have already passed
-                // authentication under the current key.
-                session.expire();
-                Err(byzantine_fault!(FaultType::FailedAuthentication, false))
-            } else {
-                drop(state);
-                drop(kex_lock);
-                Ok(ReceiveResult::Session(session, SessionEvent::Control))
-            }
+                NoiseKKPattern1 { next_retry_time, timeout, noise_message, .. } | NoiseKKPattern2 { next_retry_time, timeout, noise_message, .. } => {
+                    if let Some(ts) = process_timer(next_retry_time, App::RETRY_INTERVAL_MS, current_time) {
+                        ts
+                    } else {
+                        if *timeout <= current_time {
+                            app.event_log(LogEvent::ServiceKKTimeout(&session), current_time);
+                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
+                            drop(state);
+                            session.expire_inner(&self.0, &mut session_queue);
+                        } else {
+                            let packet_type = if let NoiseKKPattern1 { .. } = &state.outgoing_offer {
+                                app.event_log(LogEvent::ServiceKK1Resend(&session), current_time);
+                                PACKET_TYPE_NOISE_KK_PATTERN_1
+                            } else {
+                                app.event_log(LogEvent::ServiceKK2Resend(&session), current_time);
+                                PACKET_TYPE_NOISE_KK_PATTERN_2
+                            };
+                            if let Some((send, _)) = send_to(&session) {
+                                let _ = session.send_control(&state, send, packet_type, noise_message);
+                            }
+                        }
+                        retry_next
+                    }
+                }
+                KeyConfirm { next_retry_time, timeout, .. } => {
+                    if let Some(ts) = process_timer(next_retry_time, App::RETRY_INTERVAL_MS, current_time) {
+                        ts
+                    } else {
+                        if *timeout <= current_time {
+                            app.event_log(LogEvent::ServiceKeyConfirmTimeout(&session), current_time);
+                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
+                            drop(state);
+                            session.expire_inner(&self.0, &mut session_queue);
+                        } else {
+                            app.event_log(LogEvent::ServiceKeyConfirmResend(&session), current_time);
+                            if let Some((send, _)) = send_to(&session) {
+                                let _ = session.send_control(&state, send, PACKET_TYPE_KEY_CONFIRM, &[]);
+                            }
+                        }
+                        retry_next
+                    }
+                }
+                Null => retry_next,
+            };
+            session_queue.change_priority(queue_idx, Reverse(next_timer));
         }
-        _ => Err(byzantine_fault!(FaultType::InvalidPacket, false)),
-    };
+        drop(session_queue);
+
+        self.0
+            .unassociated_defrag_cache
+            .lock()
+            .unwrap()
+            .check_for_expiry(App::INITIAL_OFFER_TIMEOUT_MS, current_time);
+        self.0.unassociated_handshake_states.service(current_time);
+
+        next_service_time
+    }
 }
 
 impl<Application: ApplicationLayer> Session<Application> {
-    /// This can only fail with `MaxKeyLifetimeExceeded` or `SessionNotEstablished`.
-    fn send_control(
-        &self,
-        state: &SessionMutableState<Application>,
-        send: impl FnOnce(&mut [u8]) -> bool,
-        packet_type: u8,
-        packet: &[u8],
-    ) -> Result<(), SendError> {
-        let key = state.cipher_states[state.current_key].as_ref().ok_or(SendError::SessionNotEstablished)?;
-        let counter = self.get_next_outgoing_counter()?;
-        let mut c = self.kex_send_cipher.lock().unwrap();
-        let (mut fragment, len) = encrypt_control(
-            c.as_mut().ok_or(SendError::SessionNotEstablished)?,
-            &self.header_send_cipher,
-            packet_type,
-            counter,
-            key.remote_key_id.get(),
-            packet,
-        );
-        send(&mut fragment[..len]);
-        Ok(())
-    }
-    /// Check whether this session is established.
-    pub fn established(&self) -> bool {
-        let state = self.state.read().unwrap();
-        !matches!(&state.outgoing_offer, OfferStateMachine::NoiseXKPattern1or3(_) | OfferStateMachine::Null)
-    }
-    /// The static public key of the remote peer.
-    pub fn remote_s_public_key(&self) -> &Application::PublicKey {
-        &self.remote_static_key
-    }
-    /// The current ratchet state of this session.
-    /// The returned values are sensitive and should be securely erased before being dropped.
-    pub fn ratchet_states(&self) -> [RatchetState; 2] {
-        let state = self.state.read().unwrap();
-        state.ratchet_states.clone()
-    }
+    ///
+    ///// The current ratchet state of this session.
+    ///// The returned values are sensitive and should be securely erased before being dropped.
+    //pub fn ratchet_states(&self) -> [RatchetState; 2] {
+    //    let state = self.state.read().unwrap();
+    //    state.ratchet_states.clone()
+    //}
     /// The current ratchet count of this session.
-    pub fn ratchet_count(&self) -> u64 {
-        self.state.read().unwrap().ratchet_states[0].chain_len()
-    }
+    //pub fn ratchet_count(&self) -> u64 {
+    //    self.state.read().unwrap().
+    //}
     /// Mark a session as expired. This will make it impossible for this session to successfully
     /// receive or send data or control packets. It is recommended to simply `drop` the session
     /// instead, but this can provide some reassurance in complex shared ownership situations.
-    pub fn expire(&self) {
-        if let Some(context) = self.context.upgrade() {
-            self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
-        }
+    //pub fn expire(&self) {
+    //    if let Some(context) = self.context.upgrade() {
+    //        self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
+    //    }
+    //}
+    //fn expire_inner(
+    //    &self,
+    //    context: &Arc<ContextInner<Application>>,
+    //    session_queue: &mut IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>,
+    //) {
+    //    // Prevent this session from being updated.
+    //    session_queue.remove(self.queue_idx);
+    //    self.session_has_expired.store(true, Ordering::Relaxed);
+    //    let _kex_lock = self.state_machine_lock.lock().unwrap();
+    //    let mut state = self.state.write().unwrap();
+    //    let mut session_map = context.session_map.write().unwrap();
+    //    for key in &state.cipher_states {
+    //        if let Some(pre_id) = key.as_ref().map(|k| k.local_key_id) {
+    //            session_map.remove(&pre_id);
+    //        }
+    //    }
+    //    use OfferStateMachine::*;
+    //    match &state.outgoing_offer {
+    //        NoiseXKPattern1or3(handshake_state) => session_map.remove(&handshake_state.local_key_id),
+    //        NoiseKKPattern1 { new_key_id, .. } => session_map.remove(new_key_id),
+    //        _ => None,
+    //    };
+    //    state.outgoing_offer = OfferStateMachine::Null;
+    //}
+    /// Check whether this session is established.
+    pub fn established(&self) -> bool {
+        let state = self.state.read().unwrap();
+        !matches!(&state.beta, ZetaAutomata::A1(_) | ZetaAutomata::A3 {..} | ZetaAutomata::Null)
     }
-    fn expire_inner(
-        &self,
-        context: &Arc<ContextInner<Application>>,
-        session_queue: &mut IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>,
-    ) {
-        // Prevent this session from being updated.
-        session_queue.remove(self.queue_idx);
-        self.session_has_expired.store(true, Ordering::Relaxed);
-        let _kex_lock = self.state_machine_lock.lock().unwrap();
-        let mut state = self.state.write().unwrap();
-        let mut session_map = context.session_map.write().unwrap();
-        for key in &state.cipher_states {
-            if let Some(pre_id) = key.as_ref().map(|k| k.local_key_id) {
-                session_map.remove(&pre_id);
-            }
-        }
-        use OfferStateMachine::*;
-        match &state.outgoing_offer {
-            NoiseXKPattern1or3(handshake_state) => session_map.remove(&handshake_state.local_key_id),
-            NoiseKKPattern1 { new_key_id, .. } => session_map.remove(new_key_id),
-            _ => None,
-        };
-        state.outgoing_offer = OfferStateMachine::Null;
-    }
-
-    /// Get the next outgoing counter value.
-    fn get_next_outgoing_counter(&self) -> Result<u64, SendError> {
-        if self.session_has_expired.load(Ordering::Relaxed) {
-            Err(SendError::SessionExpired)
-        } else {
-            let counter = self.send_counter.fetch_add(1, Ordering::Relaxed);
-            if counter > THREAD_SAFE_COUNTER_HARD_EXPIRE {
-                // Because this thread sets the flag itself it will never be able to increment the
-                // counter again.
-                // For that reason the other atomic orderings can be `Relaxed`.
-                self.session_has_expired.store(true, Ordering::SeqCst)
-            }
-            Ok(counter)
-        }
-    }
-    /// Check the receive window without mutating state.
-    fn check_receive_window(&self, counter: u64) -> bool {
-        let slot = &self.counter_antireplay_window[(counter as usize) % self.counter_antireplay_window.len()];
-        let counter = counter.wrapping_add(1);
-        let prev_counter = slot.load(Ordering::Relaxed);
-        prev_counter < counter && counter.wrapping_sub(prev_counter) <= COUNTER_WINDOW_MAX_SKIP_AHEAD
-    }
-    /// Update the receive window, returning true if the packet is still valid.
-    /// This should only be called after the packet is authenticated.
-    fn update_receive_window(&self, counter: u64) -> bool {
-        let slot = &self.counter_antireplay_window[(counter as usize) % self.counter_antireplay_window.len()];
-        let counter = counter.wrapping_add(1);
-        let prev_counter = slot.fetch_max(counter, Ordering::Relaxed);
-        prev_counter < counter && counter.wrapping_sub(prev_counter) <= COUNTER_WINDOW_MAX_SKIP_AHEAD
+    /// The static public key of the remote peer.
+    pub fn remote_static_key(&self) -> &Application::PublicKey {
+        &self.s_remote
     }
 }
-impl<Application: ApplicationLayer> Drop for Session<Application> {
-    fn drop(&mut self) {
-        if let Some(context) = self.context.upgrade() {
-            self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
-        }
-    }
-}
-
-impl<Application: ApplicationLayer> NoiseXKAliceHandshake<Application> {
-    /// Can only fail with `OpenError::InvalidPublicKey` because of remote_s_public_key.
-    /// Corresponds to Noise `Initialize`.
-    fn initialize(
-        local_key_id: NonZeroU32,
-        remote_s_public_key: &Application::PublicKey,
-        ratchet_state: &[RatchetState; 2],
-        rng: &mut Application::Rng,
-    ) -> Result<
-        (
-            NoiseXKAliceHandshakeState<Application>,
-            Secret<AES_GCM_KEY_SIZE>,
-            Secret<AES_GCM_KEY_SIZE>,
-        ),
-        OpenError<Application::StorageError>,
-    > {
-        let mut message = [0u8; NoiseXKPattern1::MAX_SIZE];
-        let sha512 = &mut Application::Hash::new();
-        let hmac = &mut Application::HmacHash::new();
-        // Start of Noise XKhfs+psk2 pattern1.
-        let noise_pattern1: &mut NoiseXKPattern1 = byte_array_as_proto_buffer_mut(&mut message);
-        let noise_e_secret = Application::KeyPair::generate(rng);
-        let noise_e1_secret = pqc_kyber::keypair(rng);
-        noise_pattern1.alice_key_id = local_key_id.get().to_ne_bytes();
-        noise_pattern1.noise_e = *noise_e_secret.public_key_bytes();
-        noise_pattern1.noise_e1 = noise_e1_secret.public;
-        // Noise process prologue.
-        let noise_h = mix_hash(
-            sha512,
-            &INITIAL_H,
-            &message[NoiseXKPattern1::PROLOGUE_START..NoiseXKPattern1::PROLOGUE_END],
-        );
-        let noise_h = mix_hash(sha512, &noise_h, remote_s_public_key.as_bytes());
-        // Noise process pattern1 e token.
-        let mut noise_ck = SymmetricState::new(INITIAL_H);
-        let noise_h_e = mix_hash(sha512, &noise_h, noise_e_secret.public_key_bytes());
-        noise_ck.mix_key(hmac, noise_e_secret.public_key_bytes());
-        // Noise process pattern1 es token.
-        let mut noise_es = Secret::new();
-        if !noise_e_secret.agree(remote_s_public_key, noise_es.as_mut()) {
-            return Err(OpenError::InvalidPublicKey);
-        }
-        let noise_k_es = noise_ck.mix_key_initialize_key(hmac, noise_es.as_ref());
-        drop(noise_es);
-        // Noise process pattern1 e1 token.
-        let noise_h_ee1 = encrypt_and_hash::<Application>(
-            sha512,
-            &noise_k_es,
-            &noise_h_e,
-            PACKET_TYPE_NOISE_XK_PATTERN_1,
-            0,
-            &mut message[NoiseXKPattern1::E1_ENC_START..NoiseXKPattern1::P_ENC_START],
-        );
-        // Noise process pattern1 payload.
-        let noise_pattern1: &mut NoiseXKPattern1 = byte_array_as_proto_buffer_mut(&mut message);
-        let mut idx = 0;
-        for rs in ratchet_state {
-            if let Some(rf) = rs.fingerprint() {
-                let next_idx = idx + RATCHET_SIZE;
-                noise_pattern1.payload[idx..next_idx].copy_from_slice(rf);
-                idx = next_idx;
-            }
-        }
-        let p_auth_end = NoiseXKPattern1::P_ENC_START + idx + AES_GCM_TAG_SIZE;
-        let noise_message_len = p_auth_end + ChallengeResponse::SIZE;
-
-        let noise_h_ee1p = encrypt_and_hash::<Application>(
-            sha512,
-            &noise_k_es,
-            &noise_h_ee1,
-            PACKET_TYPE_NOISE_XK_PATTERN_1,
-            1,
-            &mut message[NoiseXKPattern1::P_ENC_START..p_auth_end],
-        );
-        drop(noise_k_es);
-        let (header_b2a_key, header_a2b_key) = noise_ck.get_ask2(hmac, LABEL_HEADER_KEY, &noise_h_ee1p);
-        let message_id = u64::from_be_bytes(message[p_auth_end - 8..p_auth_end].try_into().unwrap());
-
-        message[noise_message_len - CHALLENGE_POW_SIZE..noise_message_len].copy_from_slice(&rng.next_u64().to_ne_bytes());
-        Ok((
-            NoiseXKAliceHandshakeState::NoiseXKPattern1 {
-                noise_h_ee1p,
-                noise_e_secret,
-                noise_e1_secret: Secret(noise_e1_secret.secret),
-                noise_ck_es: noise_ck,
-                noise_message_len,
-                noise_message: message,
-                message_id,
-            },
-            header_a2b_key,
-            header_b2a_key,
-        ))
-    }
-    /// Should not fail unless Bob's public key is adversarial.
-    fn reinitialize(
-        &mut self,
-        session: &Arc<Session<Application>>,
-        ratchet_state: &[RatchetState; 2],
-        session_map: &mut HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>,
-        rng: &mut Application::Rng,
-        current_time: i64,
-    ) -> bool {
-        let local_key_id = generate_key_id(session_map, rng);
-        if let Ok((offer, a2b_header_key, b2a_header_key)) = Self::initialize(local_key_id, &session.remote_static_key, ratchet_state, rng) {
-            self.timeout = current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS);
-            session_map.remove(&self.local_key_id);
-            session_map.insert(local_key_id, (Arc::downgrade(session), false));
-            self.local_key_id = local_key_id;
-            self.offer = offer;
-            session.header_send_cipher.reset(a2b_header_key.as_ref());
-            session.header_receive_cipher.reset(b2a_header_key.as_ref());
-            true
-        } else {
-            false
-        }
-    }
-}
-
-/// Create the normal state of the offer state machine, with the correct timestamps.
-fn new_normal_state<Application: ApplicationLayer>(rand: u64, current_time: i64) -> OfferStateMachine<Application> {
-    OfferStateMachine::Normal {
-        timeout: current_time
-            .saturating_add(Application::REKEY_AFTER_TIME_MS)
-            .saturating_sub(rand as i64 % Application::REKEY_AFTER_TIME_MAX_JITTER_MS),
-    }
-}
-/// Get a timestamp of when this timer should trigger next, or None if it should trigger now.
-fn process_timer(timer: &AtomicI64, wait_time: i64, current_time: i64) -> Option<i64> {
-    let ts = timer.load(Ordering::Relaxed);
-    if ts <= current_time && timer.fetch_max(ts.saturating_add(wait_time), Ordering::Relaxed) == ts {
-        None
-    } else {
-        Some(ts)
-    }
-}
-
-/// Corresponds to Noise `EncryptAndHash`.
-fn encrypt_and_hash<Application: ApplicationLayer>(
-    sha512: &mut Application::Hash,
-    noise_k: &Secret<AES_GCM_KEY_SIZE>,
-    noise_h: &[u8; HASHLEN],
-    packet_type: u8,
-    noise_k_uses: u64,
-    message: &mut [u8],
-) -> [u8; HASHLEN] {
-    let auth_start = message.len() - AES_GCM_TAG_SIZE;
-    let mut gcm = Application::AeadEnc::new(noise_k.as_ref());
-    // Encrypt and add authentication tag.
-    gcm.set_iv(&create_message_nonce(packet_type, INIT_COUNTER + noise_k_uses));
-    gcm.set_aad(noise_h);
-    if auth_start > 0 {
-        gcm.encrypt_in_place(&mut message[..auth_start]);
-    }
-    gcm.finish_encrypt((&mut message[auth_start..]).try_into().unwrap());
-    mix_hash(sha512, noise_h, message)
-}
-/// Corresponds to Noise `DecryptAndHash`.
-fn decrypt_and_hash<Application: ApplicationLayer>(
-    sha512: &mut Application::Hash,
-    noise_k: &Secret<AES_GCM_KEY_SIZE>,
-    noise_h: &[u8; HASHLEN],
-    packet_type: u8,
-    noise_k_uses: u64,
-    message: &mut [u8],
-) -> (bool, [u8; HASHLEN]) {
-    let auth_start = message.len() - AES_GCM_TAG_SIZE;
-    let noise_h_c = mix_hash(sha512, noise_h, message);
-    let mut gcm = Application::AeadDec::new(noise_k.as_ref());
-    gcm.set_iv(&create_message_nonce(packet_type, INIT_COUNTER + noise_k_uses));
-    gcm.set_aad(noise_h);
-    if auth_start > 0 {
-        gcm.decrypt_in_place(&mut message[..auth_start]);
-    }
-    (gcm.finish_decrypt((&message[auth_start..]).try_into().unwrap()), noise_h_c)
-}
-/// Encrypt a standardized control packet.
-fn encrypt_control(
-    c: &mut impl AesGcmEnc,
-    header_cipher: &impl AesEnc,
-    packet_type: u8,
-    counter: u64,
-    remote_key_id: u32,
-    packet: &[u8],
-) -> ([u8; CONTROL_PACKET_MAX_SIZE], usize) {
-    let mut fragment = [0u8; CONTROL_PACKET_MAX_SIZE];
-    let fragment_len = packet.len() + HEADER_SIZE + AES_GCM_TAG_SIZE;
-
-    c.set_iv(&create_message_nonce(packet_type, counter));
-    if !packet.is_empty() {
-        fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE].copy_from_slice(packet);
-        c.encrypt_in_place(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE]);
-    }
-    c.finish_encrypt((&mut fragment[fragment_len - AES_GCM_TAG_SIZE..fragment_len]).try_into().unwrap());
-    set_packet_header(&mut fragment, 1, 0, packet_type, remote_key_id, counter);
-    header_cipher.encrypt_in_place((&mut fragment[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END]).try_into().unwrap());
-    (fragment, fragment_len)
-}
-fn decrypt_control<'a, IoError>(
-    c: &mut impl AesGcmDec,
-    packet_type: u8,
-    counter: u64,
-    fragment: &'a mut [u8],
-) -> Result<&'a mut [u8], ReceiveError<IoError>> {
-    let fragment_len = fragment.len();
-    if !(CONTROL_PACKET_MIN_SIZE..=CONTROL_PACKET_MAX_SIZE).contains(&fragment_len) {
-        return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-    }
-    c.set_iv(&create_message_nonce(packet_type, counter));
-    c.decrypt_in_place(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE]);
-    if !c.finish_decrypt((&fragment[fragment_len - AES_GCM_TAG_SIZE..fragment_len]).try_into().unwrap()) {
-        // This can occur naturally if one of the remote peers resent a
-        // control packet that got delayed and arrived out of order.
-        return Err(byzantine_fault!(FaultType::FailedAuthentication, true));
-    }
-    Ok(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE])
-}
-
-fn set_packet_header(packet: &mut [u8], fragment_count: u8, fragment_no: u8, packet_type: u8, remote_key_id: u32, counter_or_id: u64) {
-    debug_assert!(packet.len() >= MIN_PACKET_SIZE);
-    debug_assert!(fragment_count > 0);
-    debug_assert!(fragment_count <= MAX_FRAGMENTS as u8);
-    debug_assert!(fragment_no < MAX_FRAGMENTS as u8);
-    debug_assert_eq!((packet_type << 1) >> 1, packet_type);
-    // [0..4]   recipient key id
-    // -- start AES(ck_es * h_e_e1_p) encrypted block --
-    // [4]      fragment count (1..255)
-    // [5]      fragment number (0..254)
-    // [6]      reserved zero
-    // -- start of AES-GCM Nonce --
-    // [7]      packet type
-    // [8..16]  64-bit counter or packet id (big endian)
-    packet[4..16].copy_from_slice(&create_message_nonce(packet_type, counter_or_id));
-    packet[0..4].copy_from_slice(&remote_key_id.to_ne_bytes());
-    packet[4] = fragment_count;
-    packet[5] = fragment_no;
-    packet[6] = 0;
-}
-/// Create a 96-bit AES-GCM nonce.
-///
-/// The primary information that we want to be contained here is the counter and the
-/// packet type. The former makes this unique and the latter's inclusion authenticates
-/// it as effectively AAD. Other elements of the header are either not authenticated,
-/// like fragmentation info, or their authentication is implied via key exchange like
-/// the key id.
-fn create_message_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
-    let mut ret = [0u8; AES_GCM_IV_SIZE];
-    ret[3] = packet_type;
-    // Noise requires a big endian counter at the end of the Nonce
-    ret[4..].copy_from_slice(&counter.to_be_bytes());
-    ret
-}
-/// returns `(fragment_count, fragment_no, packet_type, counter, header_nonce)`.
-fn parse_packet_header(packet: &[u8]) -> (u8, u8, u8, u64, [u8; 10]) {
-    let header_nonce = packet[6..16].try_into().unwrap();
-    let counter = packet[8..16].try_into().unwrap();
-    // We intentionally ignore the version number for future revisions.
-    (packet[4], packet[5], packet[7], u64::from_be_bytes(counter), header_nonce)
-}
-
-/// Break a packet into fragments and send them all.
-///
-/// The contents of packet[] are mangled during this operation, so it should be discarded after.
-/// This is only used for key exchange and control packets. For data packets this is done inline
-/// for better performance with encryption and fragmentation happening at the same time.
-fn send_with_fragmentation(
-    send: &mut impl FnMut(&mut [u8]) -> bool,
-    mtu: usize,
-    packet: &mut [u8],
-    packet_type: u8,
-    remote_key_id: Option<NonZeroU32>,
-    counter_or_id: u64,
-    header_cipher: Option<&impl AesEnc>,
-) -> bool {
-    let packet_len = packet.len();
-    let fragment_count = (packet_len.saturating_add(mtu - 1)) / mtu; // integer ceiling divide
-    debug_assert!(fragment_count <= MAX_FRAGMENTS);
-    let mut fragment_start = 0;
-    let mut fragment_end = packet_len.min(mtu);
-    let mut fragment_no = 0;
-    loop {
-        let fragment = &mut packet[fragment_start..fragment_end];
-        set_packet_header(
-            fragment,
-            fragment_count as u8,
-            fragment_no as u8,
-            packet_type,
-            remote_key_id.map_or(0, |n| n.get()),
-            counter_or_id,
-        );
-        if let Some(hcc) = header_cipher {
-            hcc.encrypt_in_place((&mut fragment[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END]).try_into().unwrap());
-        }
-        if !send(fragment) {
-            return false;
-        }
-        fragment_no += 1;
-        if fragment_no < fragment_count {
-            fragment_start = fragment_end - HEADER_SIZE;
-            fragment_end = (fragment_start.saturating_add(mtu)).min(packet_len);
-        } else {
-            break;
-        }
-    }
-    true
-}
-
-/// Assemble a series of fragments into a buffer and return the length of the assembled packet in
-/// bytes.
-///
-/// This is also only used for key exchange and control packets. For data packets decryption and
-/// assembly happen in one pass for better performance.
-fn assemble_fragments_into<A: ApplicationLayer>(fragments: &[A::IncomingPacketBuffer], d: &mut [u8]) -> Result<usize, ReceiveError<A::StorageError>> {
-    let mut l = 0;
-    for i in 0..fragments.len() {
-        let mut ff = fragments[i].as_ref();
-        if i > 0 {
-            ff = &ff[HEADER_SIZE..];
-        }
-        let j = l + ff.len();
-        if j > d.len() {
-            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-        }
-        d[l..j].copy_from_slice(ff);
-        l = j;
-    }
-    Ok(l)
-}
-/// Generate a random local key id that is currently unused.
-fn generate_key_id<Application: ApplicationLayer>(
-    session_map: &HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>,
-    rng: &mut Application::Rng,
-) -> NonZeroU32 {
-    loop {
-        if let Some(local_key_id) = NonZeroU32::new(rng.next_u32()) {
-            if !session_map.contains_key(&local_key_id) {
-                return local_key_id;
-            }
-        }
-    }
-}
-
-impl<Application: ApplicationLayer> SessionKey<Application> {
-    fn new(
-        hmac: &mut Application::HmacHash,
-        ck: SymmetricState,
-        local_key_id: NonZeroU32,
-        remote_key_id: NonZeroU32,
-        current_counter: u64,
-        is_bob: bool,
-    ) -> Self {
-        let (b2a, a2b) = ck.split(hmac);
-        let (receive_key, send_key) = if is_bob {
-            (&a2b, &b2a)
-        } else {
-            (&b2a, &a2b)
-        };
-        let send_cipher_pool = std::array::from_fn(|_| Mutex::new(Application::AeadEnc::new(send_key.as_ref())));
-        let receive_cipher_pool = std::array::from_fn(|_| Mutex::new(Application::AeadDec::new(receive_key.as_ref())));
-        Self {
-            local_key_id,
-            remote_key_id,
-            send_cipher_pool,
-            receive_cipher_pool,
-            rekey_at_counter: current_counter.saturating_add(Application::REKEY_AFTER_USES),
-            expire_at_counter: current_counter.saturating_add(Application::EXPIRE_AFTER_USES),
-        }
-    }
-
-    fn get_send_cipher(&self, counter: u64) -> Result<MutexGuard<Application::AeadEnc>, SendError> {
-        if counter < self.expire_at_counter {
-            Ok(self.send_cipher_pool[(counter as usize) % self.send_cipher_pool.len()].lock().unwrap())
-        } else {
-            Err(SendError::SessionExpired)
-        }
-    }
-
-    fn get_receive_cipher(&self, counter: u64) -> MutexGuard<Application::AeadDec> {
-        let idx = (counter as usize) % self.receive_cipher_pool.len();
-        self.receive_cipher_pool[idx].lock().unwrap()
-    }
-}
-
-/// MixHash to update 'h' during negotiation.
-fn mix_hash(hasher: &mut impl Sha512, h: &[u8; HASHLEN], m: &[u8]) -> [u8; HASHLEN] {
-    let mut output = [0u8; HASHLEN];
-    hasher.reset();
-    hasher.update(h);
-    hasher.update(m);
-    hasher.finish(&mut output);
-    output
-}
-/// Check if the proof of work attached to the first message contains the correct number of leading
-/// zeros.
-fn verify_pow<Application: ApplicationLayer>(hasher: &mut Application::Hash, response: &[u8]) -> bool {
-    if Application::PROOF_OF_WORK_BIT_DIFFICULTY == 0 {
-        return true;
-    }
-    hasher.reset();
-    hasher.update(response);
-    let mut output = [0u8; HASHLEN];
-    hasher.finish(&mut output);
-    let n = u32::from_be_bytes(output[..4].try_into().unwrap());
-    n.leading_zeros() >= Application::PROOF_OF_WORK_BIT_DIFFICULTY
-}
-fn from_bytes_agreement<Application: ApplicationLayer>(
-    public: &[u8],
-    private: &Application::KeyPair,
-    output: &mut [u8; P384_ECDH_SHARED_SECRET_SIZE],
-) -> Option<Application::PublicKey> {
-    Application::PublicKey::from_bytes(public.try_into().unwrap()).and_then(|e| private.agree(&e, output).then_some(e))
-}

From 8ba0697337efdf4e5eee9e9e498c217944c40268 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 7 Aug 2023 20:04:07 -0400
Subject: [PATCH 17/50] first compile

---
 src/crypto/aes.rs      |   2 +-
 src/frag_cache.rs      |  26 +-
 src/fragged.rs         |  37 +--
 src/proto.rs           |   2 +
 src/result.rs          |  10 +-
 src/symmetric_state.rs |   2 +-
 src/zeta.rs            | 738 ++++++++++++++++++++++++++---------------
 src/zssp.rs            | 607 ++++++++++++++++++---------------
 8 files changed, 827 insertions(+), 597 deletions(-)

diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index baec450..2e5f36a 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -47,7 +47,7 @@ pub trait AesGcmEncContext {
 }
 
 pub trait AesGcmDecContext {
-    fn decrypt(&mut self, input: &[u8], output: &mut [u8]);
+    fn decrypt_in_place(&mut self, data: &mut [u8]);
 
     #[must_use]
     fn finish(&mut self, tag: &[u8; AES_GCM_TAG_SIZE]) -> bool;
diff --git a/src/frag_cache.rs b/src/frag_cache.rs
index f0c9c27..fab7a78 100644
--- a/src/frag_cache.rs
+++ b/src/frag_cache.rs
@@ -152,24 +152,12 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
             self.frags[frag_idx].write(fragment);
 
             if entry.fragment_have == 1u64.wrapping_shl(fragment_count as u32) - 1 {
-                ret_assembled.empty();
-                ret_assembled.1 = fragment_count as usize;
+                debug_assert!(ret_assembled.is_empty());
                 let start_idx = entry.frags_idx as usize;
-                // This is a ring buffer copy into ret_assembled.
-                // The fragments are moved into the `ret_assembled` container and returned.
-                // That container will drop them when it is dropped.
-                if start_idx + ret_assembled.1 <= self.frags.len() {
-                    // Copy does not occur at the buffer's boundary
-                    unsafe {
-                        std::ptr::copy_nonoverlapping(&self.frags[start_idx], &mut ret_assembled.0[0], ret_assembled.1);
-                    }
-                } else {
-                    // Copy does occur at the buffer's boundary
-                    let first_chunk_size = self.frags.len() - start_idx;
-                    let second_chunk_size = ret_assembled.1 - first_chunk_size;
-                    unsafe {
-                        std::ptr::copy_nonoverlapping(&self.frags[start_idx], &mut ret_assembled.0[0], first_chunk_size);
-                        std::ptr::copy_nonoverlapping(&self.frags[0], &mut ret_assembled.0[first_chunk_size], second_chunk_size);
+                unsafe {
+                    for i in start_idx..start_idx + fragment_count {
+
+                        ret_assembled.push(self.frags[i % self.frags.len()].assume_init_read())
                     }
                 }
                 self.invalidate::<false>(idx);
@@ -267,7 +255,7 @@ fn test_cache() {
             }
             in_progress.push((i, fragment_count as u8, packet));
         } else {
-            assembled.empty();
+            assembled.clear();
             let drop = xorshift64_random() as usize % (2 * fragment_count);
             for j in 0..fragment_count {
                 if drop != j {
@@ -297,7 +285,7 @@ fn test_cache() {
                     for _ in 0..((xorshift64_random() as usize % packet.len()) + 1) {
                         let (no, fragment) = packet.swap_remove(xorshift64_random() as usize % packet.len());
 
-                        assembled.empty();
+                        assembled.clear();
                         let mut nonce = [0; 12];
                         nonce[..4].copy_from_slice(&id.to_be_bytes());
                         cache.assemble(&nonce, 0, fragment.len(), fragment, no as usize, fragment_count as usize, 1000, time, &mut assembled);
diff --git a/src/fragged.rs b/src/fragged.rs
index 145b5d8..5cb1a49 100644
--- a/src/fragged.rs
+++ b/src/fragged.rs
@@ -6,40 +6,13 @@
  * https://www.zerotier.com/
  */
 
+use arrayvec::ArrayVec;
 use std::mem::{needs_drop, zeroed, MaybeUninit};
-use std::ptr::slice_from_raw_parts;
 
 use crate::crypto::aes::AES_GCM_IV_SIZE;
 use crate::proto::{MAX_FRAGMENTS, NONCE_SIZE_DIFF};
 
-pub(crate) struct Assembled<Fragment>(pub(crate) [MaybeUninit<Fragment>; MAX_FRAGMENTS], pub(crate) usize);
-
-impl<Fragment> Assembled<Fragment> {
-    pub(crate) fn new() -> Self {
-        Self(unsafe { MaybeUninit::<[MaybeUninit<_>; MAX_FRAGMENTS]>::uninit().assume_init() }, 0)
-    }
-    pub(crate) fn is_empty(&self) -> bool {
-        self.1 == 0
-    }
-    pub(crate) fn empty(&mut self) {
-        for i in 0..self.1 {
-            unsafe {
-                self.0.get_unchecked_mut(i).assume_init_drop();
-            }
-        }
-        self.1 = 0;
-    }
-}
-impl<Fragment> AsRef<[Fragment]> for Assembled<Fragment> {
-    fn as_ref(&self) -> &[Fragment] {
-        unsafe { &*slice_from_raw_parts(self.0.as_ptr().cast::<Fragment>(), self.1) }
-    }
-}
-impl<Fragment> Drop for Assembled<Fragment> {
-    fn drop(&mut self) {
-        self.empty()
-    }
-}
+pub type Assembled<Fragment> = ArrayVec<Fragment, MAX_FRAGMENTS>;
 
 /// Fast packet defragmenter
 pub struct Fragged<Fragment, const MAX_FRAGMENTS: usize> {
@@ -94,10 +67,10 @@ impl<Fragment, const MAX_FRAGMENTS: usize> Fragged<Fragment, MAX_FRAGMENTS> {
                     // Setting 'have' to 0 resets the state of this object, and the fragments
                     // are effectively moved into the Assembled<> container and returned. That
                     // container will drop them when it is dropped.
-                    ret_assembled.empty();
-                    ret_assembled.1 = fragment_count as usize;
                     unsafe {
-                        std::ptr::copy_nonoverlapping(&self.frags[0], &mut ret_assembled.0[0], ret_assembled.1);
+                        for i in 0..fragment_count {
+                            ret_assembled.push(self.frags[i].assume_init_read());
+                        }
                     }
                 }
             }
diff --git a/src/proto.rs b/src/proto.rs
index 3f11bb1..c11f88f 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -23,6 +23,8 @@ pub(crate) const POW_START: usize = COUNTER_SIZE + MAC_SIZE;
 pub(crate) const CHALLENGE_SIZE: usize = COUNTER_SIZE + MAC_SIZE + POW_SIZE;
 pub(crate) const DIFFICULTY: u32 = 13;
 
+pub(crate) const HEADERED_CHALLENGE_SIZE: usize = CHALLENGE_SIZE + HEADER_SIZE + KID_SIZE;
+
 /* Fragmentation constants */
 /*
 Header:
diff --git a/src/result.rs b/src/result.rs
index 4710492..c070bc9 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -61,8 +61,8 @@ pub enum FaultType {
 }
 
 /// An error that occurred during the receipt of a given packet.
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub enum ReceiveError<IoError> {
+#[derive(Debug)]
+pub enum ReceiveError<StorageError> {
     /// A type of fault that can occur because a remote peer sent us a bad packet.
     /// Such packets will be ignored by ZSSP but a user of ZSSP might want to log
     /// them for debugging or tracing.
@@ -104,7 +104,9 @@ pub enum ReceiveError<IoError> {
 
     /// One of the ratchet saving or lookup functions returned an error, so the packet had to be
     /// dropped.
-    RatchetIoError(IoError),
+    StorageError(StorageError),
+
+    IoError(std::io::Error),
 }
 
 macro_rules! byzantine_fault {
@@ -158,7 +160,7 @@ pub enum SessionEvent {
     /// This return value cannot occur after a session is fully established.
     Rejected,
     /// The received packet was valid and a data payload was decoded and authenticated.
-    Data(Vec<u8>),
+    Data,
     /// The received packet was some authentic protocol control packet. No action needs to be taken.
     Control,
 }
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index f2e2a22..591fdb4 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -152,7 +152,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
     /// Corresponds to Noise `EncryptAndHash`.
     #[must_use]
-    pub fn encrypt_and_hash_in_place<const CAP: usize>(&mut self, hash: &mut App::Hash, iv: [u8; AES_GCM_IV_SIZE], data: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE] {
+    pub fn encrypt_and_hash_in_place(&mut self, hash: &mut App::Hash, iv: [u8; AES_GCM_IV_SIZE], data: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE] {
         let tag = App::Aead::encrypt_in_place(&self.k, &iv, &self.h, data);
         hash.update(&self.h);
         hash.update(data);
diff --git a/src/zeta.rs b/src/zeta.rs
index 9203426..8475cf0 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -2,10 +2,11 @@ use arrayvec::ArrayVec;
 use rand_core::RngCore;
 use std::cmp::Reverse;
 use std::collections::HashMap;
+use std::io::Write;
 use std::num::NonZeroU32;
 use std::ops::{Deref, DerefMut};
-use std::sync::atomic::{AtomicU64, Ordering, AtomicBool};
-use std::sync::{Arc, Mutex, Weak, RwLock};
+use std::sync::atomic::{AtomicU64, Ordering, AtomicBool, AtomicI64};
+use std::sync::{Arc, Mutex, Weak, RwLock, MutexGuard, RwLockWriteGuard};
 use zeroize::Zeroizing;
 
 use crate::antireplay::Window;
@@ -21,7 +22,7 @@ use crate::crypto::kyber1024::{Kyber1024PrivateKey, KYBER_PUBLIC_KEY_SIZE, KYBER
 use crate::indexed_heap::BinaryHeapIndex;
 use crate::proto::*;
 use crate::ratchet_state::RatchetState;
-use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
+use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError, ReceiveOk};
 use crate::symmetric_state::SymmetricState;
 use crate::fragged::Fragged;
 #[cfg(feature = "logging")]
@@ -68,8 +69,8 @@ fn get_counter<App: ApplicationLayer>(session: &Session<App>, state: &MutableSta
 }
 
 /// Corresponds to the Zeta State Machine found in Section 4.1.
-pub(crate) struct Session<App: ApplicationLayer> {
-    //ctx: Weak<ContextInner<App>>,
+pub struct Session<App: ApplicationLayer> {
+    ctx: Weak<ContextInner<App>>,
     /// An arbitrary application defined object associated with each session.
     pub session_data: App::SessionData,
     /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
@@ -85,7 +86,9 @@ pub(crate) struct Session<App: ApplicationLayer> {
     pub(crate) hk_send: App::PrpEnc,
     pub(crate) hk_recv: App::PrpDec,
 
+    /// `session_queue -> state_machine_lock -> state -> session_map`
     state_machine_lock: Mutex<()>,
+    /// `session_queue -> state_machine_lock -> state -> session_map`
     pub(crate) state: RwLock<MutableState<App>>,
 
     /// Pre-computed rekeying value.
@@ -99,7 +102,7 @@ pub(crate) struct MutableState<App: ApplicationLayer> {
     key_index: bool,
     keys: [DuplexKey<App>; 2],
 
-    resend_timer: i64,
+    resend_timer: AtomicI64,
     timeout_timer: i64,
     pub beta: ZetaAutomata<App>,
 }
@@ -190,7 +193,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.mix_key(hmac, &pub_key);
         e_secret
     }
-    fn read_e<const CAP: usize>(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, i: &mut usize, packet: &[u8]) -> Option<App::PublicKey> {
+    fn read_e(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, i: &mut usize, packet: &[u8]) -> Option<App::PublicKey> {
         let j = *i + P384_PUBLIC_KEY_SIZE;
         let pub_key = &packet[*i..j];
         self.mix_hash(hash, pub_key);
@@ -227,9 +230,6 @@ impl<App: ApplicationLayer> MutableState<App> {
     fn key_mut(&mut self, is_next: bool) -> &mut DuplexKey<App> {
         &mut self.keys[(self.key_index ^ is_next) as usize]
     }
-    pub(crate) fn next_timer(&self) -> i64 {
-        self.timeout_timer.min(self.resend_timer)
-    }
 }
 
 fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_IV_SIZE]) {
@@ -265,7 +265,8 @@ fn create_a1_state<App: ApplicationLayer>(
     let (e1_secret, e1_public) = App::Kem::generate(rng.lock().unwrap().deref_mut());
     x1.extend(e1_public);
     x1.extend([0u8; AES_GCM_IV_SIZE]);
-    x1.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), &mut x1[i..]));
+    let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), &mut x1[i..]);
+    x1.extend(tag);
     // Process message pattern 1 payload.
     let i = x1.len();
     if let Some(rf) = ratchet_state1.fingerprint() {
@@ -274,7 +275,8 @@ fn create_a1_state<App: ApplicationLayer>(
     if let Some(Some(rf)) = ratchet_state2.map(|rs| rs.fingerprint()) {
         x1.try_extend_from_slice(rf).unwrap();
     }
-    x1.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 1), &mut x1[i..]));
+    let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 1), &mut x1[i..]);
+    x1.extend(tag);
 
     let c = u64::from_be_bytes(x1[x1.len() - 8..].try_into().unwrap());
 
@@ -325,7 +327,9 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
 
     let current_time = app.time();
     let queue_idx = session_queue.reserve_index();
-    let mut session = Arc::new(Session {
+    let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+    let session = Arc::new(Session {
+        ctx: Arc::downgrade(ctx),
         session_data,
         was_bob: false,
         queue_idx,
@@ -340,7 +344,7 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
             key_creation_counter: 0,
             key_index: true,
             keys: [DuplexKey::default(), DuplexKey::default()],
-            resend_timer: current_time + App::SETTINGS.resend_time as i64,
+            resend_timer: AtomicI64::new(resend_timer),
             timeout_timer: current_time + App::SETTINGS.initial_offer_timeout as i64,
             beta: ZetaAutomata::A1(a1),
         }),
@@ -349,14 +353,16 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         hk_send: App::PrpEnc::new((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap()),
         hk_recv: App::PrpDec::new((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()),
     });
-    let mut state = session.state.write().unwrap();
-    state.key_mut(true).recv.kid = Some(kid_recv);
+    {
+        let mut state = session.state.write().unwrap();
+        state.key_mut(true).recv.kid = Some(kid_recv);
+    }
 
     session_map.insert(kid_recv, Arc::downgrade(&session));
     session_queue.push_reserved(
         queue_idx,
         Arc::downgrade(&session),
-        Reverse(state.next_timer()),
+        Reverse(resend_timer),
     );
 
     send(&mut x1, None);
@@ -364,12 +370,12 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     Ok(session)
 }
 /// Corresponds to Algorithm 13 found in Section 5.
-pub(crate) fn respond_to_challenge<App: ApplicationLayer>(session: &mut Session<App>, rng: &Mutex<App::Rng>, challenge: &[u8; CHALLENGE_SIZE]) {
+pub(crate) fn respond_to_challenge<App: ApplicationLayer>(ctx: &Arc<ContextInner<App>>, session: &Session<App>,  challenge: &[u8; CHALLENGE_SIZE]) {
     let mut state = session.state.write().unwrap();
     if let ZetaAutomata::A1(a1) = &mut state.beta {
         let response_start = a1.x1.len() - CHALLENGE_SIZE;
         respond_to_challenge_in_place::<App::Rng, App::Hash>(
-            rng.lock().unwrap().deref_mut(),
+            ctx.rng.lock().unwrap().deref_mut(),
             challenge,
             (&mut a1.x1[response_start..]).try_into().unwrap(),
         );
@@ -379,8 +385,7 @@ pub(crate) fn respond_to_challenge<App: ApplicationLayer>(session: &mut Session<
 pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     app: &App,
     ctx: &ContextInner<App>,
-    remote_address: &impl std::hash::Hash,
-    n: [u8; AES_GCM_IV_SIZE],
+    n: &[u8; AES_GCM_IV_SIZE],
     x1: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
@@ -393,12 +398,6 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(InvalidPacket, true));
     }
 
-    if let Err(challenge) = ctx.challenge.process_hello::<App::Hash>(remote_address, (&x1[x1.len() - CHALLENGE_SIZE..]).try_into().unwrap()) {
-        ///
-
-        return Err(byzantine_fault!(FailedAuth, false));
-    }
-
     if &n[AES_GCM_IV_SIZE - 8..] != &x1[x1.len() - 8..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
@@ -442,7 +441,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
                 ratchet_state = Some(rs);
                 break;
             }
-            Err(e) => return Err(ReceiveError::RatchetIoError(e)),
+            Err(e) => return Err(ReceiveError::StorageError(e)),
         }
         i += RATCHET_SIZE;
     }
@@ -470,7 +469,8 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
         let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
         let ekem1 = App::Kem::encapsulate(ctx.rng.lock().unwrap().deref_mut(), (&x1[e1_start..e1_end]).try_into().unwrap(), &mut ekem1_secret).ok_or(byzantine_fault!(FailedAuth, true))?;
         x2.extend(ekem1);
-        x2.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]));
+        let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]);
+        x2.extend(tag);
         noise.mix_key(hmac, ekem1_secret.as_ref());
     }
     // Process message pattern 2 psk2 token.
@@ -480,7 +480,8 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
 
     let i = x2.len();
     x2.extend(kid_recv.get().to_be_bytes());
-    x2.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]));
+    let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]);
+    x2.extend(tag);
 
     let i = x2.len();
     let mut c = 0u64.to_be_bytes();
@@ -515,8 +516,8 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: [u8; AES_GCM_IV_SIZE],
-    mut x2: &[u8],
+    n: &[u8; AES_GCM_IV_SIZE],
+    x2: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
@@ -534,122 +535,128 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     if Some(kid) != state.key_ref(true).recv.kid {
         return Err(byzantine_fault!(UnknownLocalKeyId, true));
     }
-    let (_, c) = from_nonce(&n);
+    let (_, c) = from_nonce(n);
     if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_IV_SIZE - 3..] != &x2[x2.len() - 3..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let mut result = (|| {
-        if let ZetaAutomata::A1(a1) = &state.beta {
-            let mut noise = a1.noise.clone();
-            let mut i = 0;
-            // Process message pattern 2 e token.
-            let e_remote = noise.read_e(hash, hmac, &mut i, &x2).ok_or(byzantine_fault!(FailedAuth, true))?;
-            // Process message pattern 2 ee token.
-            noise.mix_dh(hmac, &a1.e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
-            // Process message pattern 2 ekem1 token.
-            let j = i + KYBER_CIPHERTEXT_SIZE;
-            let k = j + AES_GCM_TAG_SIZE;
-            let tag = x2[j..k].try_into().unwrap();
-            if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..j], tag) {
-                return Err(byzantine_fault!(FailedAuth, true));
+        let a1 = if let ZetaAutomata::A1(a1) = &state.beta {
+            a1
+        } else {
+            return Err(byzantine_fault!(FailedAuth, true));
+        };
+        let mut noise = a1.noise.clone();
+        let mut i = 0;
+        // Process message pattern 2 e token.
+        let e_remote = noise.read_e(hash, hmac, &mut i, &x2).ok_or(byzantine_fault!(FailedAuth, true))?;
+        // Process message pattern 2 ee token.
+        noise.mix_dh(hmac, &a1.e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        // Process message pattern 2 ekem1 token.
+        let j = i + KYBER_CIPHERTEXT_SIZE;
+        let k = j + AES_GCM_TAG_SIZE;
+        let tag = x2[j..k].try_into().unwrap();
+        if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..j], tag) {
+            return Err(byzantine_fault!(FailedAuth, true));
+        }
+        let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
+        if !a1.e1_secret.decapsulate((&x2[i..j]).try_into().unwrap(), &mut ekem1_secret) {
+            return Err(byzantine_fault!(FailedAuth, true));
+        }
+        noise.mix_key(hmac, ekem1_secret.as_ref());
+        drop(ekem1_secret);
+        i = j;
+        // We attempt to decrypt the payload at most three times. First two times with
+        // the ratchet key Alice remembers, and final time with a ratchet
+        // key of zero if Alice allows ratchet downgrades.
+        // The following code is not constant time, meaning we leak to an
+        // attacker whether or not we downgraded.
+        // We don't currently consider this sensitive enough information to hide.
+        let j = i + KID_SIZE;
+        let k = j + AES_GCM_TAG_SIZE;
+        let payload: [u8; KID_SIZE] = x2[i..j].try_into().unwrap();
+        let tag = x2[j..k].try_into().unwrap();
+        // Check for which ratchet key Bob wants to use.
+        let mut test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState<App>)> {
+            let mut noise = noise.clone();
+            let mut payload = payload.clone();
+            // Process message pattern 2 psk token.
+            noise.mix_key_and_hash(hash, hmac, ratchet_key);
+            // Process message pattern 2 payload.
+            if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut payload, tag) {
+                return None;
             }
-            let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
-            if !a1.e1_secret.decapsulate((&x2[i..j]).try_into().unwrap(), &mut ekem1_secret) {
-                return Err(byzantine_fault!(FailedAuth, true));
+            NonZeroU32::new(u32::from_be_bytes(payload)).map(|kid2| (kid2, noise))
+        };
+        // Check first key.
+        let mut ratchet_i = 1;
+        let mut chain_len = state.ratchet_state1.chain_len;
+        let mut result = test_ratchet_key(state.ratchet_state1.key.as_ref());
+        // Check second key.
+        if result.is_none() {
+            ratchet_i = 2;
+            if let Some(rs) = state.ratchet_state2.as_ref() {
+                chain_len = rs.chain_len;
+                result = test_ratchet_key(rs.key.as_ref());
             }
-            noise.mix_key(hmac, ekem1_secret.as_ref());
-            drop(ekem1_secret);
-            i = j;
-            // We attempt to decrypt the payload at most three times. First two times with
-            // the ratchet key Alice remembers, and final time with a ratchet
-            // key of zero if Alice allows ratchet downgrades.
-            // The following code is not constant time, meaning we leak to an
-            // attacker whether or not we downgraded.
-            // We don't currently consider this sensitive enough information to hide.
-            let j = i + KID_SIZE;
-            let k = j + AES_GCM_TAG_SIZE;
-            let payload: [u8; KID_SIZE] = x2[i..j].try_into().unwrap();
-            let tag = x2[j..k].try_into().unwrap();
-            // Check for which ratchet key Bob wants to use.
-            let mut test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState<App>)> {
-                let mut noise = noise.clone();
-                let mut payload = payload.clone();
-                // Process message pattern 2 psk token.
-                noise.mix_key_and_hash(hash, hmac, ratchet_key);
-                // Process message pattern 2 payload.
-                if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut payload, tag) {
-                    return None;
-                }
-                NonZeroU32::new(u32::from_be_bytes(payload)).map(|kid2| (kid2, noise))
-            };
-            // Check first key.
-            let mut ratchet_i = 1;
-            let mut chain_len = state.ratchet_state1.chain_len;
-            let mut result = test_ratchet_key(state.ratchet_state1.key.as_ref());
-            // Check second key.
-            if result.is_none() {
-                ratchet_i = 2;
-                if let Some(rs) = state.ratchet_state2.as_ref() {
-                    chain_len = rs.chain_len;
-                    result = test_ratchet_key(rs.key.as_ref());
-                }
-            }
-            // Check zero key.
-            if result.is_none() && !app.initiator_disallows_downgrade(session) {
-                chain_len = 0;
-                result = test_ratchet_key(&[0u8; RATCHET_SIZE]);
-                if result.is_some() {
-                    // TODO: add some kind of warning callback or signal.
-                }
+        }
+        // Check zero key.
+        if result.is_none() && !app.initiator_disallows_downgrade(session) {
+            chain_len = 0;
+            result = test_ratchet_key(&[0u8; RATCHET_SIZE]);
+            if result.is_some() {
+                // TODO: add some kind of warning callback or signal.
             }
+        }
 
-            let (kid_send, mut noise) = result.ok_or(byzantine_fault!(FailedAuth, true))?;
+        let (kid_send, mut noise) = result.ok_or(byzantine_fault!(FailedAuth, true))?;
 
-            let mut x3 = ArrayVec::<u8, HEADERED_HANDSHAKE_COMPLETION_MAX_SIZE>::new();
-            x3.extend([0u8; HEADER_SIZE]);
-            // Process message pattern 3 s token.
-            let i = x3.len();
-            x3.extend(ctx.s_secret.public_key_bytes());
-            x3.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..]));
-            // Process message pattern 3 se token.
-            noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
-            // Process message pattern 3 payload.
-            let i = x3.len();
-            x3.try_extend_from_slice(&a1.identity).unwrap();
-            x3.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), &mut x3[i..]));
+        let mut x3 = ArrayVec::<u8, HEADERED_HANDSHAKE_COMPLETION_MAX_SIZE>::new();
+        x3.extend([0u8; HEADER_SIZE]);
+        // Process message pattern 3 s token.
+        let i = x3.len();
+        x3.extend(ctx.s_secret.public_key_bytes());
+        let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..]);
+        x3.extend(tag);
+        // Process message pattern 3 se token.
+        noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        // Process message pattern 3 payload.
+        let i = x3.len();
+        x3.try_extend_from_slice(&a1.identity).unwrap();
+        let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), &mut x3[i..]);
+        x3.extend(tag);
 
-            let new_ratchet_state = create_ratchet_state(hmac, &mut noise, chain_len);
+        let new_ratchet_state = create_ratchet_state(hmac, &mut noise, chain_len);
 
-            let (ratchet_to_preserve, ratchet_to_delete) = if ratchet_i == 1 {
-                (Some(&state.ratchet_state1), state.ratchet_state2.as_ref())
-            } else {
-                (state.ratchet_state2.as_ref(), Some(&state.ratchet_state1))
-            };
-            let result = app.save_ratchet_state(
-                &session.s_remote,
-                &session.session_data,
-                RatchetUpdate {
-                    state1: &new_ratchet_state,
-                    state2: ratchet_to_preserve,
-                    state1_was_just_added: true,
-                    state_deleted1: ratchet_to_delete,
-                    state_deleted2: None,
-                },
-            );
-            if let Err(e) = result {
-                return Err(ReceiveError::RatchetIoError(e));
-            }
+        let (ratchet_to_preserve, ratchet_to_delete) = if ratchet_i == 1 {
+            (Some(&state.ratchet_state1), state.ratchet_state2.as_ref())
+        } else {
+            (state.ratchet_state2.as_ref(), Some(&state.ratchet_state1))
+        };
+        let result = app.save_ratchet_state(
+            &session.s_remote,
+            &session.session_data,
+            RatchetUpdate {
+                state1: &new_ratchet_state,
+                state2: ratchet_to_preserve,
+                state1_was_just_added: true,
+                state_deleted1: ratchet_to_delete,
+                state_deleted2: None,
+            },
+        );
+        if let Err(e) = result {
+            return Err(ReceiveError::StorageError(e));
+        }
 
-            let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
-            let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
-            let mut nk_recv = Zeroizing::new([0u8; HASHLEN]);
-            let mut nk_send = Zeroizing::new([0u8; HASHLEN]);
-            noise.get_ask(hmac, LABEL_KEX_KEY, &mut kek_recv, &mut kek_send);
-            noise.split(hmac, &mut nk_recv, &mut nk_send);
-            let nonce = to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0);
+        let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
+        let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
+        let mut nk_recv = Zeroizing::new([0u8; HASHLEN]);
+        let mut nk_send = Zeroizing::new([0u8; HASHLEN]);
+        noise.get_ask(hmac, LABEL_KEX_KEY, &mut kek_recv, &mut kek_send);
+        noise.split(hmac, &mut nk_recv, &mut nk_send);
+        let nonce = to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0);
 
-            //let identity = identity.clone();
-            drop(state);
+        drop(state);
+        let resend_timer = {
             let mut state = session.state.write().unwrap();
 
             state.key_mut(true).send.kid = Some(kid_send);
@@ -660,18 +667,28 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             state.ratchet_state1 = new_ratchet_state.clone();
             let current_time = app.time();
             state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
-            state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            state.resend_timer = AtomicI64::new(resend_timer);
             state.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
+            let a1 = if let ZetaAutomata::A1(a1) = &state.beta {
+                a1
+            } else {
+                // This return is unreachable.
+                return Err(byzantine_fault!(FailedAuth, true));
+            };
             state.beta = ZetaAutomata::A3 { identity: a1.identity.clone(), x3: x3.clone(), kid_send: kid_send.get(), nonce };
+            resend_timer
+        };
+        drop(kex_lock);
+        ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(resend_timer));
 
-            Ok(x3)
-        } else {
-            Err(byzantine_fault!(FailedAuth, true))
-        }
+        Ok(x3)
     })();
-    match &mut result {
-        Err(ReceiveError::ByzantineFault { .. }) => process_timers(app, ctx, session, app.time(), true, false, send),
-        Ok(mut packet) => send(&mut packet, Some(&session.hk_send)),
+    match result {
+        Err(ReceiveError::ByzantineFault { .. }) => {
+            process_timers(app, ctx, session, app.time(), true, false, send);
+        }
+        Ok(ref mut packet) => send(packet, Some(&session.hk_send)),
         _ => {}
     }
     result.map(|_| ())
@@ -680,9 +697,9 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
 pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     app: &App,
     ctx: &Arc<ContextInner<App>>,
-    zeta: StateB2<App>,
+    zeta: Arc<StateB2<App>>,
     kid: NonZeroU32,
-    mut x3: Vec<u8>,
+    x3: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<Arc<Session<App>>, ReceiveError<App::StorageError>> {
     use FaultType::*;
@@ -693,8 +710,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     if kid != zeta.kid_recv {
         return Err(byzantine_fault!(UnknownLocalKeyId, true));
     }
-    let mut hash = &mut App::Hash::new();
-    let mut hmac = &mut App::HmacHash::new();
+    let hash = &mut App::Hash::new();
+    let hmac = &mut App::HmacHash::new();
 
     let mut noise = zeta.noise.clone();
     let mut i = 0;
@@ -758,11 +775,12 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                 if !ctx.s_secret.agree(&s_remote, &mut noise_kk_ss) {
                     return Err(byzantine_fault!(FailedAuth, true));
                 }
+
+                let new_ratchet_state = create_ratchet_state(hmac, &mut noise, zeta.ratchet_state.chain_len);
                 let mut nk_recv = Zeroizing::new([0u8; HASHLEN]);
                 let mut nk_send = Zeroizing::new([0u8; HASHLEN]);
                 noise.split(hmac, &mut nk_send, &mut nk_recv);
 
-                let new_ratchet_state = create_ratchet_state(hmac, &mut noise, zeta.ratchet_state.chain_len);
                 // We must make sure the ratchet key is saved before we transition.
                 let result = app.save_ratchet_state(
                     &s_remote,
@@ -776,7 +794,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     },
                 );
                 if let Err(e) = result {
-                    return Err(ReceiveError::RatchetIoError(e));
+                    return Err(ReceiveError::StorageError(e));
                 }
 
                 let (session, current_time) = {
@@ -791,7 +809,9 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     let mut session_queue = ctx.session_queue.lock().unwrap();
                     let queue_idx = session_queue.reserve_index();
                     let current_time = app.time();
+                    let resend_timer = current_time + App::SETTINGS.resend_time as i64;
                     let session = Arc::new(Session {
+                        ctx: Arc::downgrade(ctx),
                         session_data,
                         was_bob: true,
                         s_remote,
@@ -804,7 +824,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                             key_creation_counter: c + 1,
                             key_index: false,
                             keys: [DuplexKey::default(), DuplexKey::default()],
-                            resend_timer: current_time + App::SETTINGS.resend_time as i64,
+                            resend_timer: AtomicI64::new(resend_timer),
                             timeout_timer: current_time + App::SETTINGS.rekey_timeout as i64,
                             beta: ZetaAutomata::S1,
                         }),
@@ -815,23 +835,25 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                         hk_send: App::PrpEnc::new(&zeta.hk_send),
                         hk_recv: App::PrpDec::new(&zeta.hk_recv),
                     });
+                    {
+                        let mut state = session.state.write().unwrap();
+                        state.key_mut(false).replace_nk(&nk_send, &nk_recv);
+                        state.key_mut(false).recv.kid = Some(zeta.kid_recv);
+                        state.key_mut(false).recv.replace_kek(&kek_recv);
+                        state.key_mut(false).send.kid = Some(zeta.kid_send);
+                        state.key_mut(false).send.replace_kek(&kek_send);
+                    }
 
-                    let mut state = session.state.write().unwrap();
-                    state.key_mut(false).replace_nk(&nk_send, &nk_recv);
-                    state.key_mut(false).recv.kid = Some(zeta.kid_recv);
-                    state.key_mut(false).recv.replace_kek(&kek_recv);
-                    state.key_mut(false).send.kid = Some(zeta.kid_send);
-                    state.key_mut(false).send.replace_kek(&kek_send);
-
-                    session_queue.push_reserved(queue_idx, Arc::downgrade(&session), Reverse(state.next_timer()));
+                    session_queue.push_reserved(queue_idx, Arc::downgrade(&session), Reverse(resend_timer));
                     entry.insert(Arc::downgrade(&session));
+
                     (session, current_time)
                 };
                 process_timers(app, ctx, &session, current_time, false, true, send);
 
                 Ok(session)
             }
-            Err(e) => Err(ReceiveError::RatchetIoError(e)),
+            Err(e) => Err(ReceiveError::StorageError(e)),
         }
     } else {
         if !responder_silently_rejects {
@@ -895,28 +917,31 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
                     },
                 );
                 if let Err(e) = result {
-                    return Err(ReceiveError::RatchetIoError(e));
+                    return Err(ReceiveError::StorageError(e));
                 }
             }
             drop(state);
-            let mut state_mut = session.state.write().unwrap();
-
-            state_mut.ratchet_state2 = None;
-            state_mut.key_index ^= true;
-            state_mut.timeout_timer = app.time()
-                + App::SETTINGS
-                    .rekey_after_time
-                    .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
-            state_mut.resend_timer = i64::MAX;
-            state_mut.beta = ZetaAutomata::S2;
-            drop(state);
+            let timeout_timer = {
+                let mut state = session.state.write().unwrap();
+                state.ratchet_state2 = None;
+                state.key_index ^= true;
+                state.timeout_timer = app.time()
+                    + App::SETTINGS
+                        .rekey_after_time
+                        .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+                state.resend_timer = AtomicI64::new(i64::MAX);
+                state.beta = ZetaAutomata::S2;
+                state.timeout_timer
+            };
+            drop(kex_lock);
+            ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timeout_timer));
             state = session.state.read().unwrap();
         }
     }
 
     let mut c2 = ArrayVec::<u8, HEADERED_KEY_CONFIRMATION_SIZE>::new();
     c2.extend([0u8; HEADER_SIZE]);
-    let (c, should_rekey) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
+    let (c, _) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
     let nonce = to_nonce(PACKET_TYPE_ACK, c);
     let latest_confirmed_key = state.key_ref(false).send.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
     c2.extend(App::Aead::encrypt_in_place(latest_confirmed_key, &nonce, &[], &mut []));
@@ -963,14 +988,18 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
     drop(state);
-    let mut state = session.state.write().unwrap();
-
-    state.timeout_timer = app.time()
-        + App::SETTINGS
-            .rekey_after_time
-            .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
-    state.resend_timer = i64::MAX;
-    state.beta = ZetaAutomata::S2;
+    let timeout_timer = {
+        let mut state = session.state.write().unwrap();
+        state.timeout_timer = app.time()
+            + App::SETTINGS
+                .rekey_after_time
+                .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+        state.resend_timer = AtomicI64::new(i64::MAX);
+        state.beta = ZetaAutomata::S2;
+        state.timeout_timer
+    };
+    drop(kex_lock);
+    ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timeout_timer));
     Ok(())
 }
 /// Corresponds to the trivial Transition Algorithm described for processing D packets found in
@@ -1004,8 +1033,8 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     if !session.window.update(c) {
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
-    ///
-    //zeta.expire();
+    drop(state);
+    session.expire_inner(kex_lock, session.state.write().unwrap());
     Ok(())
 }
 /// Corresponds to the timer rules of the Zeta State Machine found in Section 4.1 - Definition 3.
@@ -1017,13 +1046,13 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
     force_timeout: bool,
     force_resend: bool,
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) {
+) -> Option<i64> {
     let kex_lock = session.state_machine_lock.lock().unwrap();
     let mut state = session.state.read().unwrap();
     if force_timeout || state.timeout_timer <= current_time {
         // Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
         match &state.beta {
-            ZetaAutomata::Null => {}
+            ZetaAutomata::Null => None,
             ZetaAutomata::A1(_) | ZetaAutomata::A3 { .. } => {
                 let identity = match &state.beta {
                     ZetaAutomata::A1(a1) => &a1.identity,
@@ -1037,8 +1066,8 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
                 }
                 let new_kid_recv = remap(ctx, session, &state);
 
-                let mut hash = &mut App::Hash::new();
-                let mut hmac = &mut App::HmacHash::new();
+                let hash = &mut App::Hash::new();
+                let hmac = &mut App::HmacHash::new();
                 if let Some(a1) = create_a1_state(
                     hash,
                     hmac,
@@ -1055,20 +1084,24 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
                     let mut x1 = a1.x1.clone();
 
                     drop(state);
-                    {
+                    let resend_timer = {
                         let mut state = session.state.write().unwrap();
                         session.hk_recv.reset((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap());
                         session.hk_send.reset((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap());
                         *state.key_mut(true) = DuplexKey::default();
                         state.key_mut(true).recv.kid = Some(new_kid_recv);
-                        state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                        let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                        state.resend_timer = AtomicI64::new(resend_timer);
                         state.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
                         state.beta = ZetaAutomata::A1(a1);
-                    }
+                        resend_timer
+                    };
+                    drop(kex_lock);
 
                     send(&mut x1, None);
+                    Some(resend_timer)
                 } else {
-                    //zeta.expire();
+                    None
                 }
             }
             ZetaAutomata::S2 => {
@@ -1093,84 +1126,97 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
                 let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut k1);
                 // Process message pattern 1 es token.
                 if noise.mix_dh(hmac, &e_secret, &session.s_remote).is_none() {
-                    //zeta.expire();
-                    return;
+                    return None;
                 }
                 // Process message pattern 1 ss token.
                 noise.mix_key(hmac, session.noise_kk_ss.as_ref());
                 // Process message pattern 1 payload.
                 let i = k1.len();
                 k1.extend(new_kid_recv.get().to_be_bytes());
-                k1.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..]));
+                let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..]);
+                k1.extend(tag);
 
                 drop(state);
-                {
+                let resend_timer = {
                     let mut state = session.state.write().unwrap();
                     state.key_mut(true).recv.kid = Some(new_kid_recv);
                     state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-                    state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                    let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                    state.resend_timer = AtomicI64::new(resend_timer);
                     state.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
-                }
+                    resend_timer
+                };
+                drop(kex_lock);
                 let state = session.state.read().unwrap();
 
-                if let Some((c, should_rekey)) = get_counter(session, &state) {
+                if let Some((c, _)) = get_counter(session, &state) {
                     let nonce = to_nonce(PACKET_TYPE_REKEY_INIT, c);
-                    k1.extend(App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut k1));
+                    let tag = App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut k1);
+                    k1.extend(tag);
                     set_header(&mut k1, state.key_ref(false).send.kid.unwrap().get(), &nonce);
 
                     send(&mut k1, Some(&session.hk_send));
                 }
+                Some(resend_timer)
             }
             ZetaAutomata::S1 { .. } => {
                 log!(app, TimeoutKeyConfirm(session));
-                //zeta.expire();
+                None
             }
             ZetaAutomata::R1 { .. } => {
                 log!(app, TimeoutK1(session));
-                //zeta.expire();
+                None
             }
             ZetaAutomata::R2 { .. } => {
                 log!(app, TimeoutK2(session));
-                //zeta.expire();
+                None
             }
         }
-    } else if force_resend || state.resend_timer <= current_time {
-        // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
-        state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+    } else {
+        let ts = state.resend_timer.load(Ordering::Relaxed);
+        let resend_next = current_time + App::SETTINGS.resend_time as i64;
+        if force_resend || (ts <= current_time && state.resend_timer.fetch_max(resend_next, Ordering::Relaxed) == ts) {
+            // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
 
-        let (packet_type, mut control_payload) = match &state.beta {
-            ZetaAutomata::Null => return,
-            ZetaAutomata::A1(a1) => {
-                log!(app, ResentX1(session));
-                return send(&mut a1.x1.clone(), None);
-            }
-            ZetaAutomata::A3 { x3, .. } => {
-                log!(app, ResentX3(session));
-                return send(&mut x3.clone(), Some(&session.hk_send));
-            }
-            ZetaAutomata::S1 => {
-                log!(app, ResentKeyConfirm(session));
-                let mut c1 = ArrayVec::new();
-                c1.extend([0u8; HEADER_SIZE]);
-                (PACKET_TYPE_KEY_CONFIRM, c1)
-            }
-            ZetaAutomata::S2 => return,
-            ZetaAutomata::R1 { k1, .. } => {
-                log!(app, ResentK1(session));
-                (PACKET_TYPE_REKEY_INIT, k1.clone())
-            }
-            ZetaAutomata::R2 { k2, .. } => {
-                log!(app, ResentK2(session));
-                (PACKET_TYPE_REKEY_COMPLETE, k2.clone())
-            }
-        };
-        if let Some((c, should_rekey)) = get_counter(session, &state) {
-            let nonce = to_nonce(packet_type, c);
-            let tag = App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut control_payload);
-            control_payload.extend(tag);
-            set_header(&mut control_payload, state.key_ref(false).send.kid.unwrap().get(), &nonce);
+            let (packet_type, mut control_payload) = match &state.beta {
+                ZetaAutomata::Null => return None,
+                ZetaAutomata::A1(a1) => {
+                    log!(app, ResentX1(session));
+                    send(&mut a1.x1.clone(), None);
+                    return Some(resend_next);
+                }
+                ZetaAutomata::A3 { x3, .. } => {
+                    log!(app, ResentX3(session));
+                    send(&mut x3.clone(), Some(&session.hk_send));
+                    return Some(resend_next);
+                }
+                ZetaAutomata::S1 => {
+                    log!(app, ResentKeyConfirm(session));
+                    let mut c1 = ArrayVec::new();
+                    c1.extend([0u8; HEADER_SIZE]);
+                    (PACKET_TYPE_KEY_CONFIRM, c1)
+                }
+                ZetaAutomata::S2 => return Some(state.timeout_timer),
+                ZetaAutomata::R1 { k1, .. } => {
+                    log!(app, ResentK1(session));
+                    (PACKET_TYPE_REKEY_INIT, k1.clone())
+                }
+                ZetaAutomata::R2 { k2, .. } => {
+                    log!(app, ResentK2(session));
+                    (PACKET_TYPE_REKEY_COMPLETE, k2.clone())
+                }
+            };
+            if let Some((c, _)) = get_counter(session, &state) {
+                let nonce = to_nonce(packet_type, c);
+                let tag = App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut control_payload);
+                control_payload.extend(tag);
+                set_header(&mut control_payload, state.key_ref(false).send.kid.unwrap().get(), &nonce);
 
-            send(&mut control_payload, Some(&session.hk_send));
+                send(&mut control_payload, Some(&session.hk_send));
+            }
+            Some(resend_next)
+        } else {
+            Some(ts)
         }
     }
 }
@@ -1190,7 +1236,6 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     app: &App,
     ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
-    s_secret: &App::KeyPair,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_IV_SIZE],
     k1: &mut [u8],
@@ -1225,7 +1270,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 
     let i = k1.len() - AES_GCM_TAG_SIZE;
     let tag = k1[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut k1[..i], tag) {
+    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut k1[..i], &tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
@@ -1236,17 +1281,17 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     let result = (|| {
         let mut i = 0;
         let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_KK);
-        let mut hash = &mut App::Hash::new();
-        let mut hmac = &mut App::HmacHash::new();
+        let hash = &mut App::Hash::new();
+        let hmac = &mut App::HmacHash::new();
         // Noise process prologue.
         noise.mix_hash(hash, &session.s_remote.to_bytes());
-        noise.mix_hash(hash, &s_secret.public_key_bytes());
+        noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
         // Process message pattern 1 psk0 token.
         noise.mix_key_and_hash(hash, hmac, state.ratchet_state1.key.as_ref());
         // Process message pattern 1 e token.
         let e_remote = noise.read_e(hash, hmac, &mut i, &k1).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 es token.
-        noise.mix_dh(hmac, s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 ss token.
         noise.mix_key(hmac, session.noise_kk_ss.as_ref());
         // Process message pattern 1 payload.
@@ -1265,12 +1310,13 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         // Process message pattern 2 ee token.
         noise.mix_dh(hmac, &e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 se token.
-        noise.mix_dh(hmac, &s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 payload.
         let i = k2.len();
         let new_kid_recv = remap(ctx, session, &state);
         k2.extend(new_kid_recv.get().to_be_bytes());
-        k2.extend(noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..]));
+        let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..]);
+        k2.extend(tag);
 
         let new_ratchet_state = create_ratchet_state(hmac, &noise, state.ratchet_state1.chain_len);
         let result = app.save_ratchet_state(
@@ -1285,7 +1331,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
             },
         );
         if let Err(e) = result {
-            return Err(ReceiveError::RatchetIoError(e));
+            return Err(ReceiveError::StorageError(e));
         }
 
         let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
@@ -1296,7 +1342,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         noise.split(hmac, &mut nk_send, &mut nk_recv);
 
         drop(state);
-        {
+        let resend_timer = {
             let mut state = session.state.write().unwrap();
             state.key_mut(true).replace_nk(&nk_send, &nk_recv);
             state.key_mut(true).send.kid = Some(kid_send);
@@ -1307,24 +1353,28 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
             state.ratchet_state1 = new_ratchet_state.clone();
             let current_time = app.time();
             state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
+            let resend_timer = current_time + App::SETTINGS.resend_time as i64;
             state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-            state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            state.resend_timer = AtomicI64::new(resend_timer);
             state.beta = ZetaAutomata::R2 { k2: k2.clone() };
-        }
-        let mut state = session.state.read().unwrap();
+            resend_timer
+        };
+        drop(kex_lock);
+        ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(resend_timer));
+        let state = session.state.read().unwrap();
 
-        ///
-        let (c, should_rekey) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
+        let (c, _) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
         let nonce = to_nonce(PACKET_TYPE_REKEY_COMPLETE, c);
-        k2.extend(App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut k2));
+        let tag = App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut k2);
+        k2.extend(tag);
         set_header(&mut k2, state.key_ref(false).send.kid.unwrap().get(), &nonce);
 
         send(&mut k2, Some(&session.hk_send));
         Ok(())
     })();
-    ///
+
     if matches!(result, Err(ReceiveError::ByzantineFault { .. })) {
-        //zeta.expire();
+        session.expire();
     }
     result
 }
@@ -1335,7 +1385,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_IV_SIZE],
-    mut k2: &mut [u8],
+    k2: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
@@ -1358,7 +1408,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
 
     let i = k2.len() - AES_GCM_TAG_SIZE;
     let tag = k2[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut k2[..i], tag) {
+    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut k2[..i], &tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
@@ -1369,8 +1419,8 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
         if let ZetaAutomata::R1 { noise, e_secret, .. } = &state.beta {
             let mut noise = noise.clone();
             let mut i = 0;
-            let mut hash = &mut App::Hash::new();
-            let mut hmac = &mut App::HmacHash::new();
+            let hash = &mut App::Hash::new();
+            let hmac = &mut App::HmacHash::new();
             // Process message pattern 2 e token.
             let e_remote = noise.read_e(hash, hmac, &mut i, &k2).ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 ee token.
@@ -1399,7 +1449,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
                 },
             );
             if let Err(e) = result {
-                return Err(ReceiveError::RatchetIoError(e));
+                return Err(ReceiveError::StorageError(e));
             }
             let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
             let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
@@ -1409,7 +1459,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             noise.split(hmac, &mut nk_recv, &mut nk_send);
 
             drop(state);
-            let current_time = {
+            let (current_time, resend_timer) = {
                 let mut state = session.state.write().unwrap();
                 state.key_mut(true).replace_nk(&nk_send, &nk_recv);
                 state.key_mut(true).send.kid = Some(kid_send);
@@ -1419,11 +1469,14 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
                 state.key_index ^= true;
                 let current_time = app.time();
                 state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
+                let resend_timer = current_time + App::SETTINGS.resend_time as i64;
                 state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-                state.resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                state.resend_timer = AtomicI64::new(resend_timer);
                 state.beta = ZetaAutomata::S1;
-                current_time
+                (current_time, resend_timer)
             };
+            drop(kex_lock);
+            ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(resend_timer));
             process_timers(app, ctx, session, current_time, false, true, send);
 
             Ok(())
@@ -1431,23 +1484,156 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             unreachable!()
         }
     })();
+
     if matches!(result, Err(ReceiveError::ByzantineFault { .. })) {
-        //zeta.expire();
+        session.expire();
     }
     result
 }
+/// Corresponds to Algorithm 10 found in Section 4.3.
+pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
+    app: &App,
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
+    kid: NonZeroU32,
+    n: &[u8; AES_GCM_IV_SIZE],
+    fragments: &mut [App::IncomingPacketBuffer],
+    mut output_buffer: impl Write,
+) -> Result<(), ReceiveError<App::StorageError>> {
+    use FaultType::*;
 
-//impl<App: ApplicationLayer> Session<App> {
-//    /// Mark a session as expired. This will make it impossible for this session to successfully
-//    /// receive or send data or control packets. It is recommended to simply `drop` the session
-//    /// instead, but this can provide some reassurance in complex shared ownership situations.
-//    pub fn expire(&mut self) {
-//        self.0.lock().unwrap().expire();
-//    }
-//}
+    let kex_lock = session.state_machine_lock.lock().unwrap();
+    let state = session.state.read().unwrap();
+    let is_other = if Some(kid) == state.key_ref(true).recv.kid {
+        true
+    } else if Some(kid) == state.key_ref(false).recv.kid {
+        false
+    } else {
+        return Err(byzantine_fault!(OutOfSequence, true));
+    };
 
-//impl<App: ApplicationLayer> Drop for Session<App> {
-//    fn drop(&mut self) {
-//        self.expire();
-//    }
-//}
+    let mut cipher = state.key_ref(is_other).nk
+        .as_ref()
+        .ok_or(byzantine_fault!(OutOfSequence, true))?.start_dec(n);
+
+    // NOTE: This only works because we check the size of every received fragment in the receive
+    // function, otherwise this could panic.
+    let mut i = 0;
+    while i + 1 < fragments.len() {
+        let fragment = &mut fragments[i].as_mut()[HEADER_SIZE..];
+        cipher.decrypt_in_place(fragment);
+        i += 1;
+    }
+    let fragment = &mut fragments[i].as_mut()[HEADER_SIZE..];
+    let tag_idx = fragment.len() - AES_GCM_IV_SIZE;
+    cipher.decrypt_in_place(&mut fragment[..tag_idx]);
+    if cipher.finish((&fragment[tag_idx..]).try_into().unwrap()) {
+        return Err(byzantine_fault!(FailedAuth, true));
+    }
+
+    let (_, c) = from_nonce(n);
+    if !session.window.update(c) {
+        // This error is marked as not happening naturally, but it could occur if something about
+        // the transport protocol is duplicating packets.
+        return Err(byzantine_fault!(ExpiredCounter, true));
+    }
+
+    drop(cipher);
+    for fragment in fragments {
+        let result = output_buffer.write(&fragment.as_ref()[HEADER_SIZE..]);
+        if let Err(e) = result {
+            return Err(ReceiveError::IoError(e));
+        }
+    }
+
+    Ok(())
+}
+
+
+impl<App: ApplicationLayer> Drop for Session<App> {
+    fn drop(&mut self) {
+        self.expire();
+    }
+}
+impl<App: ApplicationLayer> Session<App> {
+    /// Mark a session as expired. This will make it impossible for this session to successfully
+    /// receive or send data or control packets. It is recommended to simply `drop` the session
+    /// instead, but this can provide some reassurance in complex shared ownership situations.
+    pub fn expire(&self) {
+        self.expire_inner(self.state_machine_lock.lock().unwrap(), self.state.write().unwrap());
+    }
+    pub(crate) fn expire_inner(&self, kex_lock: MutexGuard<'_, ()>, mut state: RwLockWriteGuard<'_, MutableState<App>>) {
+        let mut kids_to_remove = None;
+        if !matches!(&state.beta, ZetaAutomata::Null) {
+            self.session_has_expired.store(true, Ordering::Relaxed);
+            kids_to_remove = Some([state.keys[0].recv.kid, state.keys[1].recv.kid]);
+            state.keys = [DuplexKey::default(), DuplexKey::default()];
+            state.resend_timer = AtomicI64::new(i64::MAX);
+            state.timeout_timer = i64::MAX;
+            state.beta = ZetaAutomata::Null;
+        }
+        drop(state);
+        drop(kex_lock);
+        if let Some(kids_to_remove) = kids_to_remove {
+            if let Some(ctx) = self.ctx.upgrade() {
+                ctx.session_queue.lock().unwrap().remove(self.queue_idx);
+                let mut session_map = ctx.session_map.write().unwrap();
+                for kid_recv in kids_to_remove.iter().flatten() {
+                    session_map.remove(kid_recv);
+                }
+            }
+        }
+    }
+    ///
+    ///// The current ratchet state of this session.
+    ///// The returned values are sensitive and should be securely erased before being dropped.
+    //pub fn ratchet_states(&self) -> [RatchetState; 2] {
+    //    let state = self.state.read().unwrap();
+    //    state.ratchet_states.clone()
+    //}
+    /// The current ratchet count of this session.
+    //pub fn ratchet_count(&self) -> u64 {
+    //    self.state.read().unwrap().
+    //}
+    /// Mark a session as expired. This will make it impossible for this session to successfully
+    /// receive or send data or control packets. It is recommended to simply `drop` the session
+    /// instead, but this can provide some reassurance in complex shared ownership situations.
+    //pub fn expire(&self) {
+    //    if let Some(context) = self.context.upgrade() {
+    //        self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
+    //    }
+    //}
+    //fn expire_inner(
+    //    &self,
+    //    context: &Arc<ContextInner<Application>>,
+    //    session_queue: &mut IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>,
+    //) {
+    //    // Prevent this session from being updated.
+    //    session_queue.remove(self.queue_idx);
+    //    self.session_has_expired.store(true, Ordering::Relaxed);
+    //    let _kex_lock = self.state_machine_lock.lock().unwrap();
+    //    let mut state = self.state.write().unwrap();
+    //    let mut session_map = context.session_map.write().unwrap();
+    //    for key in &state.cipher_states {
+    //        if let Some(pre_id) = key.as_ref().map(|k| k.local_key_id) {
+    //            session_map.remove(&pre_id);
+    //        }
+    //    }
+    //    use OfferStateMachine::*;
+    //    match &state.outgoing_offer {
+    //        NoiseXKPattern1or3(handshake_state) => session_map.remove(&handshake_state.local_key_id),
+    //        NoiseKKPattern1 { new_key_id, .. } => session_map.remove(new_key_id),
+    //        _ => None,
+    //    };
+    //    state.outgoing_offer = OfferStateMachine::Null;
+    //}
+    /// Check whether this session is established.
+    pub fn established(&self) -> bool {
+        let state = self.state.read().unwrap();
+        !matches!(&state.beta, ZetaAutomata::A1(_) | ZetaAutomata::A3 {..} | ZetaAutomata::Null)
+    }
+    /// The static public key of the remote peer.
+    pub fn remote_static_key(&self) -> &App::PublicKey {
+        &self.s_remote
+    }
+}
diff --git a/src/zssp.rs b/src/zssp.rs
index ef49568..5af962f 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -10,6 +10,7 @@
 
 use std::cmp::Reverse;
 use std::collections::HashMap;
+use std::io::Write;
 use std::hash::Hash;
 use std::num::{NonZeroU32, NonZeroU64};
 use std::ops::DerefMut;
@@ -60,16 +61,17 @@ impl<Application: ApplicationLayer> Clone for Context<Application> {
 }
 
 pub(crate) type SessionMap<App> = RwLock<HashMap<NonZeroU32, Weak<Session<App>>>>;
-pub(crate) struct ContextInner<App: ApplicationLayer> {
+pub(crate) type SessionQueue<App> = IndexedBinaryHeap<Weak<Session<App>>, Reverse<i64>>;
+pub struct ContextInner<App: ApplicationLayer> {
     pub rng: Mutex<App::Rng>,
     pub(crate) s_secret: App::KeyPair,
-    pub(crate) session_queue: Mutex<IndexedBinaryHeap<Weak<Session<App>>, Reverse<i64>>>,
+    /// `session_queue -> state_machine_lock -> state -> session_map`
+    pub(crate) session_queue: Mutex<SessionQueue<App>>,
+    /// `session_queue -> state_machine_lock -> state -> session_map`
     pub(crate) session_map: SessionMap<App>,
     pub(crate) unassociated_defrag_cache: Mutex<UnassociatedFragCache<App::IncomingPacketBuffer>>,
     pub(crate) unassociated_handshake_states: UnassociatedHandshakeCache<App>,
-    //pub(crate) b2_map: Mutex<HashMap<NonZeroU32, StateB2<App>>>,
 
-    //hello_defrag: Mutex<DefragBuffer>,
     pub(crate) challenge: ChallengeContext,
 }
 
@@ -80,7 +82,7 @@ pub enum IncomingSessionAction {
     Drop,
 }
 
-fn parse_fragment_header<App: ApplicationLayer>(incoming_fragment: &[u8]) -> Result<(usize, usize, [u8; AES_GCM_IV_SIZE]), ReceiveError<App::StorageError>> {
+fn parse_fragment_header<StorageError>(incoming_fragment: &[u8]) -> Result<(usize, usize, [u8; AES_GCM_IV_SIZE]), ReceiveError<StorageError>> {
     let fragment_no = incoming_fragment[FRAGMENT_NO_IDX] as usize;
     let fragment_count = incoming_fragment[FRAGMENT_COUNT_IDX] as usize;
     if fragment_no >= fragment_count || fragment_count > MAX_FRAGMENTS {
@@ -92,6 +94,43 @@ fn parse_fragment_header<App: ApplicationLayer>(incoming_fragment: &[u8]) -> Res
 }
 
 
+/// Fragments and sends the packet, destroying it in the process.
+///
+/// Corresponds to the fragmentation algorithm described in Section 6.
+fn send_with_fragmentation<PrpEnc: AesEnc>(
+    mut send: impl FnMut(&mut [u8]) -> bool,
+    mtu: usize,
+    headered_packet: &mut [u8],
+    hk_send: Option<&PrpEnc>,
+) -> bool {
+    let payload_len = headered_packet.len() - HEADER_SIZE;
+    let payload_mtu = mtu - HEADER_SIZE;
+    debug_assert!(payload_mtu >= 4);
+    let fragment_count = payload_len.saturating_add(payload_mtu - 1) / payload_mtu; // Ceiling div.
+    let fragment_base_size = payload_len / fragment_count;
+    let fragment_size_remainder = payload_len % fragment_count;
+
+    let mut i = HEADER_SIZE;
+    for fragment_no in 0..fragment_count {
+        let j = i + fragment_base_size + (fragment_no < fragment_size_remainder) as usize;
+        let fragment = &mut headered_packet[i - HEADER_SIZE..j];
+
+        fragment[FRAGMENT_NO_IDX] = fragment_no as u8;
+        fragment[FRAGMENT_COUNT_IDX] = fragment_count as u8;
+
+        if let Some(hk_send) = hk_send {
+            hk_send.encrypt_in_place(
+                (&mut fragment[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap(),
+            );
+        }
+        if !send(fragment) {
+            return false;
+        }
+        i = j;
+    }
+    true
+}
+
 impl<App: ApplicationLayer> Context<App> {
     /// Create a new session context.
     pub fn new(static_secret_key: App::KeyPair, mut rng: App::Rng) -> Self {
@@ -143,6 +182,9 @@ impl<App: ApplicationLayer> Context<App> {
             static_remote_key,
             session_data,
             identity,
+            |packet, hk_send| {
+                send_with_fragmentation(send, mtu, packet, hk_send);
+            }
         )
     }
 
@@ -186,9 +228,8 @@ impl<App: ApplicationLayer> Context<App> {
         mut send_unassociated_mtu: usize,
         mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
         remote_address: &impl Hash,
-        data_buf: &'a mut [u8],
         mut incoming_fragment_buf: App::IncomingPacketBuffer,
-        current_time: i64,
+        output_buffer: impl Write,
     ) -> Result<ReceiveOk<App>, ReceiveError<App::StorageError>> {
         use crate::result::FaultType::*;
         let ctx = &self.0;
@@ -198,21 +239,175 @@ impl<App: ApplicationLayer> Context<App> {
             return Err(byzantine_fault!(FaultType::InvalidPacket, false));
         }
 
-        // The first section parses the header and looks up relevant state information. If it's a DATA
-        // or NOP packet it gets handled right here, otherwise we pull out a set of variables and
-        // continue to the logic that handles KEX and session control packets.
+        let mut fragment_buffer = Assembled::new();
 
-        let mut assembled_packet = Assembled::new(); // needs to outlive the block below
-        let mut incoming = None;
-        let (session, packet_type, fragments) = {
-            let kid_recv = incoming_fragment[0..KID_SIZE].try_into().unwrap();
-            // `from_ne_bytes` because this id was generated locally.
-            if let Some(kid_recv) = NonZeroU32::new(u32::from_ne_bytes(kid_recv)) {
-                let session_map = self.0.session_map.read().unwrap();
-                let session = ctx.session_map.read().unwrap().get(&kid_recv).map(|r| r.upgrade());
-                if let Some(Some(session)) = session {
-                    drop(session_map);
-                    session.hk_recv.decrypt_in_place(
+        let kid_recv = incoming_fragment[0..KID_SIZE].try_into().unwrap();
+        if let Some(kid_recv) = NonZeroU32::new(u32::from_be_bytes(kid_recv)) {
+            let session_map = self.0.session_map.read().unwrap();
+            let session = ctx.session_map.read().unwrap().get(&kid_recv).map(|r| r.upgrade());
+            if let Some(Some(session)) = session {
+                drop(session_map);
+                session.hk_recv.decrypt_in_place(
+                    (&mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
+                        .try_into()
+                        .unwrap(),
+                );
+
+                let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
+                let (packet_type, incoming_counter) = from_nonce(&nonce);
+
+                {//vrfy
+                    if packet_type != PACKET_TYPE_DATA {
+                        log!(app, ReceivedRawFragment(p, c, fragment_no, fragment_count));
+                    }
+                    if packet_type == PACKET_TYPE_HANDSHAKE_RESPONSE {
+                        if !matches!(&session.state.read().unwrap().beta, ZetaAutomata::A1(_)) {
+                            // A resent handshake response from Bob may have arrived out of order,
+                            // after we already received one.
+                            return Err(byzantine_fault!(OutOfSequence, false));
+                        }
+                        if incoming_counter >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
+                            return Err(byzantine_fault!(ExpiredCounter, true));
+                        }
+                    } else if PACKET_TYPE_USES_COUNTER_RANGE.contains(&packet_type) {
+                        // For DOS resistant reply-protection we need to check that the given counter is
+                        // in the window of valid counters immediately.
+                        // But for packets larger than 1 fragment we can't actually record the
+                        // counter as received until we've authenticated the packet.
+                        // So we check the counter window twice, and only update it the second time
+                        // after the packet has been authenticated.
+                        if !session.window.check(incoming_counter) {
+                            // This can occur naturally if packets arrive way out of order, or
+                            // if they are duplicates.
+                            // This can also be naturally triggered if Bob has just successfully
+                            // received the first session key and is reject all of Alice's resends.
+                            // This can also occur if a session was manually expired, but not
+                            // dropped, and the remote party is still sending us data.
+                            return Err(byzantine_fault!(ExpiredCounter, false));
+                        }
+                    } else if packet_type == PACKET_TYPE_HANDSHAKE_COMPLETION {
+                        // This can be triggered if Bob successfully received a session key and
+                        // needs to reject all of Alice's resends of PACKET_TYPE_NOISE_XK_PATTERN_3.
+                        return Err(byzantine_fault!(InvalidPacket, false));
+                    } else {
+                        return Err(byzantine_fault!(InvalidPacket, true));
+                    }
+                }
+
+                // Handle defragmentation.
+                let ret = if packet_type == PACKET_TYPE_DATA {
+                    let fragments = if fragment_count > 1 {
+                        let idx = incoming_counter as usize % session.defrag.len();
+                        session.defrag[idx].lock().unwrap().assemble(
+                            &nonce,
+                            incoming_fragment_buf,
+                            fragment_no,
+                            fragment_count,
+                            &mut fragment_buffer,
+                        );
+                        if fragment_buffer.is_empty() {
+                            return Ok(ReceiveOk::Unassociated);
+                        } else {
+                            // We have not yet authenticated the sender so we do not report
+                            // receiving a packet from them.
+                            fragment_buffer.as_mut()
+                        }
+                    } else {
+                        std::slice::from_mut(&mut incoming_fragment_buf)
+                    };
+                    receive_payload_in_place(app, ctx, &session, kid_recv, &nonce, fragments, output_buffer)?;
+                    SessionEvent::Data
+                } else {
+                    let mut buffer = ArrayVec::<u8, HANDSHAKE_RESPONSE_SIZE>::new();
+                    let assembled_packet = if fragment_count > 1 {
+                        let idx = incoming_counter as usize % session.defrag.len();
+                        session.defrag[idx].lock().unwrap().assemble(
+                            &nonce,
+                            incoming_fragment_buf,
+                            fragment_no,
+                            fragment_count,
+                            &mut fragment_buffer,
+                        );
+                        if fragment_buffer.is_empty() {
+                            return Ok(ReceiveOk::Unassociated);
+                        } else {
+                            for fragment in fragment_buffer.as_ref() {
+                                buffer.try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..]).map_err(|_| byzantine_fault!(InvalidPacket, true))?;
+                            }
+                            // We have not yet authenticated the sender so we do not report
+                            // receiving a packet from them.
+                            buffer.as_mut()
+                        }
+                    } else {
+                        &mut incoming_fragment_buf.as_mut()[HEADER_SIZE..]
+                    };
+
+                    let send_associated = |packet: &mut [u8], hk_send: Option<&App::PrpEnc>| {
+                        if let Some((send_fragment, mut mtu)) = send_to(&session) {
+                            mtu = mtu.max(MIN_TRANSPORT_MTU);
+                            send_with_fragmentation(send_fragment, mtu, packet, hk_send);
+                        }
+                    };
+                    match packet_type {
+                        PACKET_TYPE_HANDSHAKE_RESPONSE => {
+                            log!(app, ReceivedRawX2);
+                            received_x2_trans(
+                                app,
+                                ctx,
+                                &session,
+                                kid_recv,
+                                &nonce,
+                                assembled_packet,
+                                send_associated,
+                            )?;
+                            log!(app, X2IsAuthSentX3(&session));
+                            SessionEvent::Control
+                        }
+                        PACKET_TYPE_KEY_CONFIRM => {
+                            log!(app, ReceivedRawKeyConfirm);
+                            let result =
+                                received_c1_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet,send_associated)?;
+                            log!(app, KeyConfirmIsAuthSentAck(&session));
+                            if result {
+                                SessionEvent::Established
+                            } else {
+                                SessionEvent::Control
+                            }
+                        }
+                        PACKET_TYPE_ACK => {
+                            log!(app, ReceivedRawAck);
+                            received_c2_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet)?;
+                            log!(app, AckIsAuth(&session));
+                            SessionEvent::Control
+                        }
+                        PACKET_TYPE_REKEY_INIT => {
+                            log!(app, ReceivedRawK1);
+                            received_k1_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet, send_associated)?;
+                            log!(app, K1IsAuthSentK2(&session));
+                            SessionEvent::Control
+                        }
+                        PACKET_TYPE_REKEY_COMPLETE => {
+                            log!(app, ReceivedRawK2);
+                            received_k2_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet, send_associated)?;
+                            log!(app, K2IsAuthSentKeyConfirm(&session));
+                            SessionEvent::Control
+                        }
+                        PACKET_TYPE_SESSION_REJECTED => {
+                            log!(app, ReceivedRawD);
+                            received_d_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet)?;
+                            log!(app, DIsAuthClosedSession(&session));
+                            SessionEvent::Rejected
+                        }
+                        _ => return Err(byzantine_fault!(InvalidPacket, true)), // This is unreachable.
+                    }
+                };
+                Ok(ReceiveOk::Session(session, ret))
+            } else {
+                drop(session_map);
+                // Check for and handle PACKET_TYPE_ALICE_NOISE_XK_PATTERN_3
+                let zeta = self.0.unassociated_handshake_states.get(kid_recv);
+                if let Some(zeta) = zeta {
+                    App::PrpDec::new(&zeta.hk_recv).decrypt_in_place(
                         (&mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
                             .try_into()
                             .unwrap(),
@@ -222,211 +417,150 @@ impl<App: ApplicationLayer> Context<App> {
                     let (packet_type, incoming_counter) = from_nonce(&nonce);
 
                     {//vrfy
-                        if packet_type != PACKET_TYPE_DATA {
-                            log!(app, ReceivedRawFragment(p, c, fragment_no, fragment_count));
-                        }
-                        if packet_type == PACKET_TYPE_HANDSHAKE_RESPONSE {
-                            if !matches!(&session.state.read().unwrap().beta, ZetaAutomata::A1(_)) {
-                                // A resent handshake response from Bob may have arrived out of order,
-                                // after we already received one.
-                                return Err(byzantine_fault!(OutOfSequence, false));
-                            }
-                            if incoming_counter >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
-                                return Err(byzantine_fault!(ExpiredCounter, true));
-                            }
-                        } else if PACKET_TYPE_USES_COUNTER_RANGE.contains(&packet_type) {
-                            // For DOS resistant reply-protection we need to check that the given counter is
-                            // in the window of valid counters immediately.
-                            // But for packets larger than 1 fragment we can't actually record the
-                            // counter as received until we've authenticated the packet.
-                            // So we check the counter window twice, and only update it the second time
-                            // after the packet has been authenticated.
-                            if !session.window.check(incoming_counter) {
-                                // This can occur naturally if packets arrive way out of order, or
-                                // if they are duplicates.
-                                // This can also be naturally triggered if Bob has just successfully
-                                // received the first session key and is reject all of Alice's resends.
-                                // This can also occur if a session was manually expired, but not
-                                // dropped, and the remote party is still sending us data.
-                                return Err(byzantine_fault!(ExpiredCounter, false));
-                            }
-                        } else if packet_type == PACKET_TYPE_HANDSHAKE_COMPLETION {
-                            // This can be triggered if Bob successfully received a session key and
-                            // needs to reject all of Alice's resends of PACKET_TYPE_NOISE_XK_PATTERN_3.
-                            return Err(byzantine_fault!(InvalidPacket, false));
-                        } else {
-                            return Err(byzantine_fault!(InvalidPacket, true));
+                        log!(app, ReceivedRawFragment(packet_type, incoming_counter, frag_no, frag_count));
+                        if packet_type != PACKET_TYPE_HANDSHAKE_COMPLETION || incoming_counter != 0 {
+                            return Err(byzantine_fault!(InvalidPacket, true))
                         }
                     }
 
-                    // Handle defragmentation.
-                    let fragments = if fragment_count > 1 {
-                        let idx = incoming_counter as usize % session.defrag.len();
-                        session.defrag[idx].lock().unwrap().assemble(
+                    let mut buffer = ArrayVec::<u8, HANDSHAKE_COMPLETION_MAX_SIZE>::new();
+                    let assembled_packet = if fragment_count > 1 {
+                        zeta.defrag.lock().unwrap().assemble(
                             &nonce,
                             incoming_fragment_buf,
                             fragment_no,
                             fragment_count,
-                            &mut assembled_packet,
+                            &mut fragment_buffer
                         );
-                        if assembled_packet.is_empty() {
-                            // We have not yet authenticated the sender so we do not report
-                            // receiving a packet from them.
+                        if fragment_buffer.is_empty() {
                             return Ok(ReceiveOk::Unassociated);
                         } else {
-                            assembled_packet.as_ref()
+                            for fragment in fragment_buffer.as_ref() {
+                                buffer.try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..]).map_err(|_| byzantine_fault!(InvalidPacket, true))?;
+                            }
+                            buffer.as_mut()
                         }
                     } else {
-                        std::slice::from_ref(&incoming_fragment_buf)
+                        &mut incoming_fragment_buf.as_mut()[HEADER_SIZE..]
                     };
-
-                    match packet_type {
-                        PACKET_TYPE_DATA => {
-                            let state = session.state.read().unwrap();
-                            // The error here can occur because the other party is using a brand new
-                            // session key that we have not received yet.
-                            let key = state.cipher_states[key_index]
-                                .as_ref()
-                                .ok_or(byzantine_fault!(FaultType::OutOfSequence, true))?;
-                            let mut c = key.get_receive_cipher(incoming_counter);
-                            c.set_iv(&create_message_nonce(packet_type, incoming_counter));
-
-                            let mut data_len = 0;
-
-                            // Decrypt fragments 0..N-1 where N is the number of fragments.
-                            for f in fragments[..(fragments.len() - 1)].iter() {
-                                let f: &[u8] = f.as_ref();
-                                debug_assert!(f.len() >= HEADER_SIZE);
-                                let current_frag_data_start = data_len;
-                                data_len += f.len() - HEADER_SIZE;
-                                if data_len > data_buf.len() {
-                                    return Err(ReceiveError::DataBufferTooSmall);
-                                }
-                                c.decrypt(&f[HEADER_SIZE..], &mut data_buf[current_frag_data_start..data_len]);
-                            }
-
-                            // Decrypt final fragment (or only fragment if not fragmented)
-                            let current_frag_data_start = data_len;
-                            let last_fragment = fragments.last().unwrap().as_ref();
-                            if last_fragment.len() < (HEADER_SIZE + AES_GCM_TAG_SIZE) {
-                                return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                            }
-                            data_len += last_fragment.len() - (HEADER_SIZE + AES_GCM_TAG_SIZE);
-                            if data_len > data_buf.len() {
-                                return Err(ReceiveError::DataBufferTooSmall);
-                            }
-                            let payload_end = last_fragment.len() - AES_GCM_TAG_SIZE;
-                            c.decrypt(&last_fragment[HEADER_SIZE..payload_end], &mut data_buf[current_frag_data_start..data_len]);
-
-                            let aead_authentication_ok = c.finish_decrypt(&last_fragment[payload_end..].try_into().unwrap());
-                            drop(c);
-                            drop(state);
-
-                            if !aead_authentication_ok {
-                                return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                            }
-                            if !session.update_receive_window(incoming_counter) {
-                                // This can be naturally triggered because Bob has just
-                                // successfully received a session key and needs to reject
-                                // all of Alice's resends.
-                                // This can also occur naturally if some part of the outer
-                                // system is duplicating the packets being sent to us.
-                                // We are safely deduplicating them here.
-                                return Err(byzantine_fault!(FaultType::ExpiredCounter, true));
-                            }
-                            // Packet fully authenticated
-                            return Ok(ReceiveOk::Session(session, SessionEvent::Data(&mut data_buf[..data_len])));
-                        }
-                        PACKET_TYPE_HANDSHAKE_RESPONSE => {
-                            (Some(session), packet_type, fragments)
-                        }
-                    }
-                } else {
-                    drop(session_map);
-                    // Check for and handle PACKET_TYPE_ALICE_NOISE_XK_PATTERN_3
-                    incoming = self.0.unassociated_handshake_states.get(kid_recv);
-                    if let Some(incoming) = incoming.as_ref() {
-                        App::PrpDec::new(&incoming.hk_recv).decrypt_in_place(
-                            (&mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
-                                .try_into()
-                                .unwrap(),
-                        );
-
-                        let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
-                        let (packet_type, incoming_counter) = from_nonce(&nonce);
-
-                        {//vrfy
-                            log!(app, ReceivedRawFragment(packet_type, incoming_counter, frag_no, frag_count));
-                            if packet_type != PACKET_TYPE_HANDSHAKE_COMPLETION || incoming_counter != 0 {
-                               return Err(byzantine_fault!(InvalidPacket, true))
-                            }
-                        }
-
-                        let fragments = if fragment_count > 1 {
-                            incoming.defrag.lock().unwrap().assemble(
-                                &nonce,
-                                incoming_fragment_buf,
-                                fragment_no,
-                                fragment_count,
-                                &mut assembled_packet,
-                            );
-                            if !assembled_packet.is_empty() {
-                                assembled_packet.as_ref()
-                            } else {
-                                return Ok(ReceiveOk::Unassociated);
-                            }
-                        } else {
-                            std::slice::from_ref(&incoming_fragment_buf)
-                        };
-                        // We must guarantee that this incoming handshake is processed once and only
-                        // once. This prevents catastrophic nonce reuse caused by multithreading.
-                        if self.0.unassociated_handshake_states.remove(kid_recv) {
-                            (None, PACKET_TYPE_HANDSHAKE_COMPLETION, fragments)
-                        } else {
-                            return Ok(ReceiveOk::Unassociated);
-                        }
-                    } else {
-                        // This can occur naturally because either Bob's incoming_sessions cache got
-                        // full so Alice's incoming session was dropped, or the session this packet
-                        // was for was dropped by the application.
-                        return Err(byzantine_fault!(UnknownLocalKeyId, true));
-                    }
-                }
-            } else {
-                let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
-                let (packet_type, incoming_counter) = from_nonce(&nonce);
-
-                {//vrfy
-                    log!(app, ReceivedRawFragment(packet_type, incoming_counter, frag_no, frag_count));
-                    if packet_type != PACKET_TYPE_HANDSHAKE_HELLO && packet_type != PACKET_TYPE_CHALLENGE {
-                        return Err(byzantine_fault!(InvalidPacket, true))
-                    }
-                }
-
-                let fragments = if fragment_count > 1 {
-                    self.0.unassociated_defrag_cache.lock().unwrap().assemble(
-                        &nonce,
-                        remote_address,
-                        incoming_fragment.len() - HEADER_SIZE,
-                        incoming_fragment_buf,
-                        fragment_no,
-                        fragment_count,
-                        App::SETTINGS.resend_time as i64,
-                        current_time,
-                        &mut assembled_packet,
-                    );
-                    if !assembled_packet.is_empty() {
-                        assembled_packet.as_ref()
-                    } else {
+                    // We must guarantee that this incoming handshake is processed once and only
+                    // once. This prevents catastrophic nonce reuse caused by multithreading.
+                    if !self.0.unassociated_handshake_states.remove(kid_recv) {
                         return Ok(ReceiveOk::Unassociated);
                     }
+
+                    log!(app, ReceivedRawX3);
+                    let session = received_x3_trans(app, ctx, zeta, kid_recv, assembled_packet, |packet, hk_send| {
+                        send_with_fragmentation(
+                            send_unassociated_reply,
+                            send_unassociated_mtu,
+                            packet,
+                            hk_send,
+                        );
+                    })?;
+                    log!(app, X3IsAuthSentKeyConfirm(&session));
+                    Ok(ReceiveOk::Session(session, SessionEvent::NewSession))
                 } else {
-                    std::array::from_ref(&incoming_fragment_buf)
-                };
-                (None, packet_type, fragments)
+                    // This can occur naturally because either Bob's incoming_sessions cache got
+                    // full so Alice's incoming session was dropped, or the session this packet
+                    // was for was dropped by the application.
+                    return Err(byzantine_fault!(UnknownLocalKeyId, true));
+                }
             }
-        };
+        } else {
+            let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
+            let (packet_type, _c) = from_nonce(&nonce);
+
+            {//vrfy
+                log!(app, ReceivedRawFragment(packet_type, _c, frag_no, frag_count));
+                if packet_type != PACKET_TYPE_HANDSHAKE_HELLO && packet_type != PACKET_TYPE_CHALLENGE {
+                    return Err(byzantine_fault!(InvalidPacket, true))
+                }
+            }
+
+            let mut buffer = ArrayVec::<u8, HANDSHAKE_HELLO_MAX_SIZE>::new();
+            let assembled_packet = if fragment_count > 1 {
+                self.0.unassociated_defrag_cache.lock().unwrap().assemble(
+                    &nonce,
+                    remote_address,
+                    incoming_fragment.len() - HEADER_SIZE,
+                    incoming_fragment_buf,
+                    fragment_no,
+                    fragment_count,
+                    App::SETTINGS.resend_time as i64,
+                    app.time(),
+                    &mut fragment_buffer
+                );
+                if fragment_buffer.is_empty() {
+                    return Ok(ReceiveOk::Unassociated);
+                } else {
+                    for fragment in fragment_buffer.as_ref() {
+                        buffer.try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..]).map_err(|_| byzantine_fault!(InvalidPacket, true))?;
+                    }
+                    buffer.as_mut()
+                }
+            } else {
+                &mut incoming_fragment_buf.as_mut()[HEADER_SIZE..]
+            };
+
+            if packet_type == PACKET_TYPE_HANDSHAKE_HELLO {
+                log!(app, ReceivedRawX1);
+
+                if !(HANDSHAKE_HELLO_CHALLENGE_MIN_SIZE..=HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE).contains(&assembled_packet.len()) {
+                    return Err(byzantine_fault!(InvalidPacket, true));
+                }
+                // Process recv challenge layer.
+                let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
+                let result = ctx.challenge.process_hello::<App::Hash>(remote_address, (&assembled_packet[challenge_start..]).try_into().unwrap());
+                if let Err(challenge) = result {
+                    log!(app, X1FailedChallengeSentNewChallenge);
+                    let mut challenge_packet = ArrayVec::<u8, HEADERED_CHALLENGE_SIZE>::new();
+                    challenge_packet.extend([0u8; HEADER_SIZE]);
+                    challenge_packet.try_extend_from_slice(&assembled_packet[..KID_SIZE]).unwrap();
+                    challenge_packet.extend(challenge);
+                    let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
+                    challenge_packet[FRAGMENT_COUNT_IDX] = 1;
+                    challenge_packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce);
+
+                    send_unassociated_reply(&mut challenge_packet);
+                    // If we issue a challenge the first hello packet will always fail.
+                    return Err(byzantine_fault!(FailedAuth, false));
+                } else {
+                    log!(app, X1SucceededChallenge);
+                }
+
+                // Process recv zeta layer.
+                received_x1_trans(app, ctx, &nonce, assembled_packet, |packet, hk_send| {
+                    send_with_fragmentation(
+                        send_unassociated_reply,
+                        send_unassociated_mtu,
+                        packet,
+                        hk_send,
+                    );
+                })?;
+                log!(app, X1IsAuthSentX2);
+
+                Ok(ReceiveOk::Unassociated)
+            } else if packet_type == PACKET_TYPE_CHALLENGE {
+                log!(app, ReceivedRawChallenge);
+                // Process recv challenge layer.
+                if assembled_packet.len() != KID_SIZE + CHALLENGE_SIZE {
+                    return Err(byzantine_fault!(InvalidPacket, true));
+                }
+                if let Some(kid_recv) = NonZeroU32::new(u32::from_be_bytes(assembled_packet[..KID_SIZE].try_into().unwrap())) {
+                    if let Some(Some(session)) = ctx.session_map.read().unwrap().get(&kid_recv).map(|r| r.upgrade()) {
+                        respond_to_challenge(ctx, &session, &assembled_packet[KID_SIZE..].try_into().unwrap());
+                        log!(app, ChallengeIsAuth(&session));
+                        return Ok(ReceiveOk::Unassociated);
+                    }
+                }
+                Err(byzantine_fault!(UnknownLocalKeyId, true))
+            } else {
+                Err(byzantine_fault!(InvalidPacket, true))
+            }
+        }
     }
+    /*
     /// Send data over the session.
     ///
     /// * `session` - The session to send to
@@ -672,60 +806,5 @@ impl<App: ApplicationLayer> Context<App> {
         self.0.unassociated_handshake_states.service(current_time);
 
         next_service_time
-    }
-}
-
-impl<Application: ApplicationLayer> Session<Application> {
-    ///
-    ///// The current ratchet state of this session.
-    ///// The returned values are sensitive and should be securely erased before being dropped.
-    //pub fn ratchet_states(&self) -> [RatchetState; 2] {
-    //    let state = self.state.read().unwrap();
-    //    state.ratchet_states.clone()
-    //}
-    /// The current ratchet count of this session.
-    //pub fn ratchet_count(&self) -> u64 {
-    //    self.state.read().unwrap().
-    //}
-    /// Mark a session as expired. This will make it impossible for this session to successfully
-    /// receive or send data or control packets. It is recommended to simply `drop` the session
-    /// instead, but this can provide some reassurance in complex shared ownership situations.
-    //pub fn expire(&self) {
-    //    if let Some(context) = self.context.upgrade() {
-    //        self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
-    //    }
-    //}
-    //fn expire_inner(
-    //    &self,
-    //    context: &Arc<ContextInner<Application>>,
-    //    session_queue: &mut IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>,
-    //) {
-    //    // Prevent this session from being updated.
-    //    session_queue.remove(self.queue_idx);
-    //    self.session_has_expired.store(true, Ordering::Relaxed);
-    //    let _kex_lock = self.state_machine_lock.lock().unwrap();
-    //    let mut state = self.state.write().unwrap();
-    //    let mut session_map = context.session_map.write().unwrap();
-    //    for key in &state.cipher_states {
-    //        if let Some(pre_id) = key.as_ref().map(|k| k.local_key_id) {
-    //            session_map.remove(&pre_id);
-    //        }
-    //    }
-    //    use OfferStateMachine::*;
-    //    match &state.outgoing_offer {
-    //        NoiseXKPattern1or3(handshake_state) => session_map.remove(&handshake_state.local_key_id),
-    //        NoiseKKPattern1 { new_key_id, .. } => session_map.remove(new_key_id),
-    //        _ => None,
-    //    };
-    //    state.outgoing_offer = OfferStateMachine::Null;
-    //}
-    /// Check whether this session is established.
-    pub fn established(&self) -> bool {
-        let state = self.state.read().unwrap();
-        !matches!(&state.beta, ZetaAutomata::A1(_) | ZetaAutomata::A3 {..} | ZetaAutomata::Null)
-    }
-    /// The static public key of the remote peer.
-    pub fn remote_static_key(&self) -> &Application::PublicKey {
-        &self.s_remote
-    }
+    } */
 }

From ff80eeaf685fde99cfd037bc58013fbb88143968 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 7 Aug 2023 20:04:42 -0400
Subject: [PATCH 18/50] cargo fmt

---
 src/antireplay.rs       |   2 +-
 src/applicationlayer.rs |   9 +-
 src/challenge.rs        |  12 +-
 src/crypto/aes.rs       |  24 +++-
 src/crypto/kyber1024.rs |  12 +-
 src/crypto/mod.rs       |   2 +-
 src/crypto/sha512.rs    |   1 -
 src/frag_cache.rs       |  49 +++++--
 src/indexed_heap.rs     |   6 +-
 src/lib.rs              |  10 +-
 src/log_event.rs        |  11 +-
 src/proto.rs            |  18 ++-
 src/symmetric_state.rs  |  45 ++++--
 src/zeta.rs             | 307 +++++++++++++++++++++++++++++++---------
 src/zssp.rs             | 101 +++++++------
 15 files changed, 446 insertions(+), 163 deletions(-)

diff --git a/src/antireplay.rs b/src/antireplay.rs
index 80cd707..81bc5a0 100644
--- a/src/antireplay.rs
+++ b/src/antireplay.rs
@@ -1,6 +1,6 @@
 use std::sync::atomic::{AtomicU64, Ordering};
 
-pub struct Window<const L: usize, const MAX: u64> ([AtomicU64; L]);
+pub struct Window<const L: usize, const MAX: u64>([AtomicU64; L]);
 
 impl<const L: usize, const MAX: u64> Window<L, MAX> {
     pub fn new() -> Self {
diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 2dcfc96..4d7fcfc 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -11,10 +11,10 @@ use crate::crypto::aes::{AesDec, AesEnc, HighThroughputAesGcmPool, LowThroughput
 use crate::crypto::kyber1024::Kyber1024PrivateKey;
 use crate::crypto::p384::{P384KeyPair, P384PublicKey};
 use crate::crypto::rand_core::{CryptoRng, RngCore};
-use crate::crypto::sha512::{HmacSha512, HashSha512};
-use crate::RatchetState;
+use crate::crypto::sha512::{HashSha512, HmacSha512};
 use crate::proto::RATCHET_SIZE;
 use crate::zeta::Session;
+use crate::RatchetState;
 //use crate::{log_event::LogEvent, Session};
 
 /// A container for a vast majority of the dynamic settings within ZSSP, including all time-based settings.
@@ -210,7 +210,10 @@ pub trait ApplicationLayer: Sized {
     /// If `RatchetAction::DowngradeRatchet` is returned we will attempt to convince Alice to downgrade
     /// to the empty ratchet key, restarting the ratchet chain.
     /// If `RatchetAction::FailAuthentication` is returned Alice's connection will be silently dropped.
-    fn restore_by_fingerprint(&self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, Self::StorageError>;
+    fn restore_by_fingerprint(
+        &self,
+        ratchet_fingerprint: &[u8; RATCHET_SIZE],
+    ) -> Result<Option<RatchetState>, Self::StorageError>;
     /// Lookup the specific ratchet states based on the identity of the peer being communicated with.
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
diff --git a/src/challenge.rs b/src/challenge.rs
index c47af7b..11e4578 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -4,12 +4,15 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use rand_core::{CryptoRng, RngCore};
 
 use crate::antireplay::Window;
-use crate::crypto::{secure_eq, sha512::{HashSha512, SHA512_HASH_SIZE}};
+use crate::crypto::{
+    secure_eq,
+    sha512::{HashSha512, SHA512_HASH_SIZE},
+};
 use crate::proto::*;
 
 pub struct ChallengeContext {
     counter: AtomicU64,
-    antireplay_window: Window<COUNTER_WINDOW_MAX_OOO, {u64::MAX}>,
+    antireplay_window: Window<COUNTER_WINDOW_MAX_OOO, { u64::MAX }>,
     salt: [u8; SALT_SIZE],
 }
 
@@ -57,7 +60,10 @@ impl ChallengeContext {
     ) -> Result<(), [u8; CHALLENGE_SIZE]> {
         let c = u64::from_be_bytes(response[..COUNTER_SIZE].try_into().unwrap());
         let mut work_buf = [0u8; SHA512_HASH_SIZE];
-        if self.antireplay_window.check(c) && secure_eq(&response[COUNTER_SIZE..POW_START], &self.create_mac::<Hash>(c, addr)) && verify_pow::<Hash>(response, &mut work_buf) {
+        if self.antireplay_window.check(c)
+            && secure_eq(&response[COUNTER_SIZE..POW_START], &self.create_mac::<Hash>(c, addr))
+            && verify_pow::<Hash>(response, &mut work_buf)
+        {
             self.antireplay_window.update(c);
             Ok(())
         } else {
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index 2e5f36a..9a4e242 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -39,7 +39,6 @@ pub trait AesDec: Send + Sync {
     fn decrypt_in_place(&self, block: &mut [u8; AES_256_BLOCK_SIZE]);
 }
 
-
 pub trait AesGcmEncContext {
     fn encrypt(&mut self, input: &[u8], output: &mut [u8]);
 
@@ -54,8 +53,12 @@ pub trait AesGcmDecContext {
 }
 
 pub trait HighThroughputAesGcmPool: Send + Sync {
-    type EncContext<'a>: AesGcmEncContext where Self: 'a;
-    type DecContext<'a>: AesGcmDecContext where Self: 'a;
+    type EncContext<'a>: AesGcmEncContext
+    where
+        Self: 'a;
+    type DecContext<'a>: AesGcmDecContext
+    where
+        Self: 'a;
 
     fn new(encrypt_key: &[u8; AES_256_KEY_SIZE], decrypt_key: &[u8; AES_256_KEY_SIZE]) -> Self;
 
@@ -64,7 +67,18 @@ pub trait HighThroughputAesGcmPool: Send + Sync {
 }
 
 pub trait LowThroughputAesGcm {
-    fn encrypt_in_place(key: &[u8; AES_256_KEY_SIZE], iv: &[u8; AES_GCM_IV_SIZE], aad: &[u8], data: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE];
+    fn encrypt_in_place(
+        key: &[u8; AES_256_KEY_SIZE],
+        iv: &[u8; AES_GCM_IV_SIZE],
+        aad: &[u8],
+        data: &mut [u8],
+    ) -> [u8; AES_GCM_TAG_SIZE];
     #[must_use]
-    fn decrypt_in_place(key: &[u8; AES_256_KEY_SIZE], iv: &[u8; AES_GCM_IV_SIZE], aad: &[u8], data: &mut [u8], tag: &[u8; AES_GCM_TAG_SIZE]) -> bool;
+    fn decrypt_in_place(
+        key: &[u8; AES_256_KEY_SIZE],
+        iv: &[u8; AES_GCM_IV_SIZE],
+        aad: &[u8],
+        data: &mut [u8],
+        tag: &[u8; AES_GCM_TAG_SIZE],
+    ) -> bool;
 }
diff --git a/src/crypto/kyber1024.rs b/src/crypto/kyber1024.rs
index 5cccc30..74c9571 100644
--- a/src/crypto/kyber1024.rs
+++ b/src/crypto/kyber1024.rs
@@ -25,12 +25,20 @@ pub trait Kyber1024PrivateKey<Rng: RngCore + CryptoRng>: Sized + Send + Sync {
     /// **CRITICAL**: This must return `None` if the given `public_key` is invalid in any way
     /// according to the Kyber1024 spec.
     #[must_use]
-    fn encapsulate(rng: &mut Rng, public_key: &[u8; KYBER_PUBLIC_KEY_SIZE], plaintext_out: &mut [u8; KYBER_PLAINTEXT_SIZE]) -> Option<[u8; KYBER_CIPHERTEXT_SIZE]>;
+    fn encapsulate(
+        rng: &mut Rng,
+        public_key: &[u8; KYBER_PUBLIC_KEY_SIZE],
+        plaintext_out: &mut [u8; KYBER_PLAINTEXT_SIZE],
+    ) -> Option<[u8; KYBER_CIPHERTEXT_SIZE]>;
     /// Decapsulate a Kyber1024 `ciphertext` received from the remote peer, retreiving
     /// the raw bytes of the original plaintext. This plaintext is immediately hashed and deleted.
     ///
     /// **CRITICAL**: This must return `None` if the given `ciphertext` is invalid in any way
     /// according to the Kyber1024 spec.
     #[must_use]
-    fn decapsulate(&self, ciphertext: &[u8; KYBER_CIPHERTEXT_SIZE], plaintext_out: &mut [u8; KYBER_PLAINTEXT_SIZE]) -> bool;
+    fn decapsulate(
+        &self,
+        ciphertext: &[u8; KYBER_CIPHERTEXT_SIZE],
+        plaintext_out: &mut [u8; KYBER_PLAINTEXT_SIZE],
+    ) -> bool;
 }
diff --git a/src/crypto/mod.rs b/src/crypto/mod.rs
index 22dcb9a..f31b7f6 100644
--- a/src/crypto/mod.rs
+++ b/src/crypto/mod.rs
@@ -1,9 +1,9 @@
 // (c) 2020-2022 ZeroTier, Inc. -- currently proprietary pending actual release and licensing. See LICENSE.md.
 
 pub mod aes;
+pub mod kyber1024;
 pub mod p384;
 pub mod sha512;
-pub mod kyber1024;
 
 // We re-export our dependencies so it is less of a headache for the implementor to use the same
 // exact version of them.
diff --git a/src/crypto/sha512.rs b/src/crypto/sha512.rs
index bfb4b0d..94178c1 100644
--- a/src/crypto/sha512.rs
+++ b/src/crypto/sha512.rs
@@ -13,7 +13,6 @@ pub trait HashSha512 {
     fn finish_and_reset(&mut self, output: &mut [u8; SHA512_HASH_SIZE]);
 }
 
-
 /// Opaque HMAC-SHA-512 implementation.
 /// Does not need to be threadsafe.
 pub trait HmacSha512 {
diff --git a/src/frag_cache.rs b/src/frag_cache.rs
index fab7a78..e132f4c 100644
--- a/src/frag_cache.rs
+++ b/src/frag_cache.rs
@@ -67,7 +67,10 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
         ret_assembled: &mut Assembled<Fragment>,
     ) {
         debug_assert!(MAX_FRAGMENTS < MAX_UNASSOCIATED_FRAGMENTS);
-        if fragment_no >= fragment_count || fragment_count > MAX_FRAGMENTS || fragment_size > MAX_UNASSOCIATED_PACKET_SIZE {
+        if fragment_no >= fragment_count
+            || fragment_count > MAX_FRAGMENTS
+            || fragment_size > MAX_UNASSOCIATED_PACKET_SIZE
+        {
             return;
         }
 
@@ -144,7 +147,10 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
 
         let new_size = entry.packet_size + fragment_size as u32;
         let got = 1u64.wrapping_shl(fragment_no as u32);
-        if got & entry.fragment_have == 0 && fragment_count == entry.fragment_count as usize && new_size <= MAX_UNASSOCIATED_PACKET_SIZE as u32 {
+        if got & entry.fragment_have == 0
+            && fragment_count == entry.fragment_count as usize
+            && new_size <= MAX_UNASSOCIATED_PACKET_SIZE as u32
+        {
             entry.packet_size = new_size;
             entry.fragment_have |= got;
 
@@ -156,7 +162,6 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
                 let start_idx = entry.frags_idx as usize;
                 unsafe {
                     for i in start_idx..start_idx + fragment_count {
-
                         ret_assembled.push(self.frags[i % self.frags.len()].assume_init_read())
                     }
                 }
@@ -263,13 +268,30 @@ fn test_cache() {
                     // If the timeout is 1 we should be guaranteed to get our packet cached.
                     let mut nonce = [0; 12];
                     nonce[..4].copy_from_slice(&i.to_be_bytes());
-                    cache.assemble(&nonce, 0, fragment.len(), fragment, j, fragment_count, 1, time, &mut assembled);
+                    cache.assemble(
+                        &nonce,
+                        0,
+                        fragment.len(),
+                        fragment,
+                        j,
+                        fragment_count,
+                        1,
+                        time,
+                        &mut assembled,
+                    );
                     time += 1;
                 }
             }
             if drop >= fragment_count {
-                assert!(!assembled.is_empty(), "Packet was dropped from the cache when it shouldn't have");
-                assert_eq!(assembled.as_ref().len(), fragment_count, "Cache returned the wrong packet");
+                assert!(
+                    !assembled.is_empty(),
+                    "Packet was dropped from the cache when it shouldn't have"
+                );
+                assert_eq!(
+                    assembled.as_ref().len(),
+                    fragment_count,
+                    "Cache returned the wrong packet"
+                );
                 for j in 0..fragment_count {
                     assert_eq!(assembled.as_ref()[j][7], r, "Cache returned a corrupted packet");
                 }
@@ -281,14 +303,25 @@ fn test_cache() {
             if in_progress.len() > 0 {
                 let to_remain = (xorshift64_random() as usize % in_progress_fragments) + 16;
                 while in_progress_fragments > to_remain {
-                    let (id, fragment_count, mut packet) = in_progress.swap_remove(xorshift64_random() as usize % in_progress.len());
+                    let (id, fragment_count, mut packet) =
+                        in_progress.swap_remove(xorshift64_random() as usize % in_progress.len());
                     for _ in 0..((xorshift64_random() as usize % packet.len()) + 1) {
                         let (no, fragment) = packet.swap_remove(xorshift64_random() as usize % packet.len());
 
                         assembled.clear();
                         let mut nonce = [0; 12];
                         nonce[..4].copy_from_slice(&id.to_be_bytes());
-                        cache.assemble(&nonce, 0, fragment.len(), fragment, no as usize, fragment_count as usize, 1000, time, &mut assembled);
+                        cache.assemble(
+                            &nonce,
+                            0,
+                            fragment.len(),
+                            fragment,
+                            no as usize,
+                            fragment_count as usize,
+                            1000,
+                            time,
+                            &mut assembled,
+                        );
                         time += 1;
                         in_progress_fragments -= 1;
 
diff --git a/src/indexed_heap.rs b/src/indexed_heap.rs
index 70085dc..c83b8ca 100644
--- a/src/indexed_heap.rs
+++ b/src/indexed_heap.rs
@@ -52,7 +52,8 @@ impl<T, P: Ord> IndexedBinaryHeap<T, P> {
             let child0_idx = parent_idx * 2 + 1;
             let child1_idx = child0_idx + 1;
             if child0_idx < self.data.len() {
-                let largest_child = if child1_idx < self.data.len() && self.data[child1_idx].1 > self.data[child0_idx].1 {
+                let largest_child = if child1_idx < self.data.len() && self.data[child1_idx].1 > self.data[child0_idx].1
+                {
                     child1_idx
                 } else {
                     child0_idx
@@ -155,7 +156,8 @@ impl<T, P: Ord> IndexedBinaryHeap<T, P> {
             .map(|data_idx| std::mem::replace(&mut self.data[data_idx].0, new_item))
     }
     pub fn get(&self, idx: BinaryHeapIndex) -> Option<(&T, &P)> {
-        self.deref_index(idx).map(|data_idx| (&self.data[data_idx].0, &self.data[data_idx].1))
+        self.deref_index(idx)
+            .map(|data_idx| (&self.data[data_idx].0, &self.data[data_idx].1))
     }
     pub fn get_mut(&mut self, idx: BinaryHeapIndex) -> Option<(&mut T, &P)> {
         self.deref_index(idx).map(|data_idx| {
diff --git a/src/lib.rs b/src/lib.rs
index 61c0db5..44a6e59 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,20 +7,20 @@
  */
 pub mod crypto;
 
+mod antireplay;
 mod applicationlayer;
-mod fragged;
+mod challenge;
 mod frag_cache;
+mod fragged;
 mod handshake_cache;
 mod indexed_heap;
 mod log_event;
 mod proto;
 mod ratchet_state;
-mod symmetric_state;
-mod antireplay;
-mod challenge;
 pub mod result;
-mod zssp;
+mod symmetric_state;
 mod zeta;
+mod zssp;
 //mod context;
 
 //pub mod error;
diff --git a/src/log_event.rs b/src/log_event.rs
index cf96367..8690bf9 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -7,7 +7,7 @@
  */
 use std::sync::Arc;
 
-use crate::{ApplicationLayer, zeta::Session};
+use crate::{zeta::Session, ApplicationLayer};
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
 pub enum LogEvent<'a, Application: ApplicationLayer> {
@@ -51,9 +51,12 @@ impl<'a, Application: ApplicationLayer> std::fmt::Debug for LogEvent<'a, Applica
             ServiceKKTimeout(_) => write!(f, "ServiceKKTimeout"),
             ServiceKeyConfirmResend(_) => write!(f, "ServiceKeyConfirmResend"),
             ServiceKeyConfirmTimeout(_) => write!(f, "ServiceKeyConfirmTimeout"),
-            ReceiveUnassociatedFragment(arg0, arg1, arg2) => {
-                f.debug_tuple("ReceiveUnassociatedFragment").field(arg0).field(arg1).field(arg2).finish()
-            }
+            ReceiveUnassociatedFragment(arg0, arg1, arg2) => f
+                .debug_tuple("ReceiveUnassociatedFragment")
+                .field(arg0)
+                .field(arg1)
+                .field(arg2)
+                .finish(),
             ReceiveUncheckedXK1 => write!(f, "ReceiveUncheckedXK1"),
             ReceiveCheckXK1Challenge(arg0) => f.debug_tuple("ReceiveCheckXK1Challenge").field(arg0).finish(),
             ReceiveValidXK1 => write!(f, "ReceiveValidXK1"),
diff --git a/src/proto.rs b/src/proto.rs
index c11f88f..d7d5eaf 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -1,4 +1,9 @@
-use crate::crypto::{aes::{AES_GCM_TAG_SIZE, AES_GCM_IV_SIZE}, kyber1024::{KYBER_CIPHERTEXT_SIZE, KYBER_PUBLIC_KEY_SIZE}, p384::P384_PUBLIC_KEY_SIZE, sha512::SHA512_HASH_SIZE};
+use crate::crypto::{
+    aes::{AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE},
+    kyber1024::{KYBER_CIPHERTEXT_SIZE, KYBER_PUBLIC_KEY_SIZE},
+    p384::P384_PUBLIC_KEY_SIZE,
+    sha512::SHA512_HASH_SIZE,
+};
 
 /* Common constants */
 
@@ -75,7 +80,8 @@ pub(crate) const HASHLEN: usize = SHA512_HASH_SIZE;
 pub const RATCHET_SIZE: usize = 32;
 
 /// Initial value of 'h'.
-pub(crate) const PROTOCOL_NAME_NOISE_XK: &[u8; HASHLEN] = b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+pub(crate) const PROTOCOL_NAME_NOISE_XK: &[u8; HASHLEN] =
+    b"Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 /// Initial value of 'ck' for rekeying.
 pub(crate) const PROTOCOL_NAME_NOISE_KK: &[u8; HASHLEN] =
     b"Noise_KKpsk0_P384_AESGCM_SHA512\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
@@ -101,7 +107,7 @@ pub(crate) const COUNTER_WINDOW_MAX_SKIP_AHEAD: u64 = 1 << 24;
 /// When Bob issues a challenge to Alice to mitigate DDOS, Bob will only accept Alice's
 /// response once, and then its attached counter is added to the window.
 pub(crate) const CHALLENGE_COUNTER_WINDOW_MAX_OOO: usize = 32;
-pub(crate) const THREAD_SAFE_COUNTER_HARD_EXPIRE: u64 = u64::MAX - 1<<16;
+pub(crate) const THREAD_SAFE_COUNTER_HARD_EXPIRE: u64 = u64::MAX - 1 << 16;
 
 /* Packet constants */
 
@@ -117,7 +123,8 @@ pub(crate) const PACKET_TYPE_DATA: u8 = 8;
 pub(crate) const PACKET_TYPE_CHALLENGE: u8 = 9;
 pub(crate) const PACKET_TYPE_USES_COUNTER_RANGE: std::ops::Range<u8> = 3..9;
 
-pub(crate) const HANDSHAKE_HELLO_MIN_SIZE: usize = KID_SIZE + P384_PUBLIC_KEY_SIZE + KYBER_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const HANDSHAKE_HELLO_MIN_SIZE: usize =
+    KID_SIZE + P384_PUBLIC_KEY_SIZE + KYBER_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
 pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RATCHET_SIZE;
 
 pub(crate) const HANDSHAKE_HELLO_CHALLENGE_MIN_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + CHALLENGE_SIZE;
@@ -125,7 +132,8 @@ pub(crate) const HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE: usize = HANDSHAKE_HELLO_MAX
 
 pub(crate) const HEADERED_HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE: usize = HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE + HEADER_SIZE;
 
-pub(crate) const HANDSHAKE_RESPONSE_SIZE: usize = P384_PUBLIC_KEY_SIZE + KYBER_CIPHERTEXT_SIZE + AES_GCM_TAG_SIZE + KID_SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const HANDSHAKE_RESPONSE_SIZE: usize =
+    P384_PUBLIC_KEY_SIZE + KYBER_CIPHERTEXT_SIZE + AES_GCM_TAG_SIZE + KID_SIZE + AES_GCM_TAG_SIZE;
 pub(crate) const HEADERED_HANDSHAKE_RESPONSE_SIZE: usize = HANDSHAKE_RESPONSE_SIZE + HEADER_SIZE;
 
 pub(crate) const HANDSHAKE_COMPLETION_MIN_SIZE: usize = P384_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + 0 + AES_GCM_TAG_SIZE;
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 591fdb4..e2f0e5c 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -3,10 +3,10 @@ use std::marker::PhantomData;
 use arrayvec::ArrayVec;
 use zeroize::Zeroizing;
 
-use crate::crypto::aes::{LowThroughputAesGcm, HighThroughputAesGcmPool, AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE};
+use crate::crypto::aes::{HighThroughputAesGcmPool, LowThroughputAesGcm, AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE};
 use crate::crypto::sha512::{HashSha512, HmacSha512};
-use crate::{applicationlayer::ApplicationLayer, crypto::aes::AES_256_KEY_SIZE};
 use crate::proto::*;
+use crate::{applicationlayer::ApplicationLayer, crypto::aes::AES_256_KEY_SIZE};
 
 pub struct SymmetricState<App: ApplicationLayer> {
     k: Zeroizing<[u8; AES_256_KEY_SIZE]>,
@@ -27,7 +27,6 @@ impl<App: ApplicationLayer> Clone for SymmetricState<App> {
     }
 }
 
-
 impl<App: ApplicationLayer> SymmetricState<App> {
     /// HMAC-SHA512 key derivation based on KBKDF Counter Mode:
     /// https://csrc.nist.gov/publications/detail/sp/800-108/rev-1/final.
@@ -93,7 +92,15 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
         let mut temp_k = Zeroizing::new([0u8; HASHLEN]);
 
-        self.kbkdf(hmac, input_key_material, LABEL_KBKDF_CHAIN, 2, &mut next_ck, Some(&mut temp_k), None);
+        self.kbkdf(
+            hmac,
+            input_key_material,
+            LABEL_KBKDF_CHAIN,
+            2,
+            &mut next_ck,
+            Some(&mut temp_k),
+            None,
+        );
 
         *self.ck = *next_ck;
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
@@ -133,7 +140,12 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
     /// Corresponds to Noise `MixKeyAndHash`.
-    pub fn mix_key_and_hash_no_init(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, input_key_material: &[u8]) {
+    pub fn mix_key_and_hash_no_init(
+        &mut self,
+        hash: &mut App::Hash,
+        hmac: &mut App::HmacHash,
+        input_key_material: &[u8],
+    ) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
         let mut temp_h = [0u8; HASHLEN];
 
@@ -152,7 +164,12 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
     /// Corresponds to Noise `EncryptAndHash`.
     #[must_use]
-    pub fn encrypt_and_hash_in_place(&mut self, hash: &mut App::Hash, iv: [u8; AES_GCM_IV_SIZE], data: &mut [u8]) -> [u8; AES_GCM_TAG_SIZE] {
+    pub fn encrypt_and_hash_in_place(
+        &mut self,
+        hash: &mut App::Hash,
+        iv: [u8; AES_GCM_IV_SIZE],
+        data: &mut [u8],
+    ) -> [u8; AES_GCM_TAG_SIZE] {
         let tag = App::Aead::encrypt_in_place(&self.k, &iv, &self.h, data);
         hash.update(&self.h);
         hash.update(data);
@@ -162,7 +179,13 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
     /// Corresponds to Noise `DecryptAndHash`.
     #[must_use]
-    pub fn decrypt_and_hash_in_place(&mut self, hash: &mut App::Hash, iv: [u8; AES_GCM_IV_SIZE], data: &mut [u8], tag: [u8; AES_GCM_TAG_SIZE]) -> bool {
+    pub fn decrypt_and_hash_in_place(
+        &mut self,
+        hash: &mut App::Hash,
+        iv: [u8; AES_GCM_IV_SIZE],
+        data: &mut [u8],
+        tag: [u8; AES_GCM_TAG_SIZE],
+    ) -> bool {
         hash.update(&self.h);
         hash.update(data);
         hash.update(&tag);
@@ -178,7 +201,13 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     /// is forward secrect and is cryptographically independent from all other produced keys.
     /// Based on Noise's unstable ASK mechanism, using KBKDF instead of HKDF.
     /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
-    pub fn get_ask(&self, hmac: &mut App::HmacHash, label: &[u8; 4], key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
+    pub fn get_ask(
+        &self,
+        hmac: &mut App::HmacHash,
+        label: &[u8; 4],
+        key1: &mut [u8; HASHLEN],
+        key2: &mut [u8; HASHLEN],
+    ) {
         self.kbkdf(hmac, &self.h, label, 2, key1, Some(key2), None);
     }
     /// Used for internally debugging a key exchange.
diff --git a/src/zeta.rs b/src/zeta.rs
index 8475cf0..f0b0c4a 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -5,26 +5,28 @@ use std::collections::HashMap;
 use std::io::Write;
 use std::num::NonZeroU32;
 use std::ops::{Deref, DerefMut};
-use std::sync::atomic::{AtomicU64, Ordering, AtomicBool, AtomicI64};
-use std::sync::{Arc, Mutex, Weak, RwLock, MutexGuard, RwLockWriteGuard};
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockWriteGuard, Weak};
 use zeroize::Zeroizing;
 
 use crate::antireplay::Window;
 use crate::applicationlayer::ApplicationLayer;
 use crate::applicationlayer::RatchetUpdate;
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
-use crate::zssp::{ContextInner, log};
+use crate::zssp::{log, ContextInner};
 //use crate::context::{log, ContextInner, SessionMap};
 use crate::crypto::aes::*;
+use crate::crypto::kyber1024::{
+    Kyber1024PrivateKey, KYBER_CIPHERTEXT_SIZE, KYBER_PLAINTEXT_SIZE, KYBER_PUBLIC_KEY_SIZE,
+};
 use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
 use crate::crypto::sha512::{HashSha512, HmacSha512};
-use crate::crypto::kyber1024::{Kyber1024PrivateKey, KYBER_PUBLIC_KEY_SIZE, KYBER_CIPHERTEXT_SIZE, KYBER_PLAINTEXT_SIZE};
+use crate::fragged::Fragged;
 use crate::indexed_heap::BinaryHeapIndex;
 use crate::proto::*;
 use crate::ratchet_state::RatchetState;
-use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError, ReceiveOk};
+use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError};
 use crate::symmetric_state::SymmetricState;
-use crate::fragged::Fragged;
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
 
@@ -50,11 +52,19 @@ pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
     let c_start = n.len() - 8;
     (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
 }
-fn create_ratchet_state<App: ApplicationLayer>(hmac: &mut App::HmacHash, noise: &SymmetricState<App>, pre_chain_len: u64) -> RatchetState {
+fn create_ratchet_state<App: ApplicationLayer>(
+    hmac: &mut App::HmacHash,
+    noise: &SymmetricState<App>,
+    pre_chain_len: u64,
+) -> RatchetState {
     let mut rk = Zeroizing::new([0u8; HASHLEN]);
     let mut rf = Zeroizing::new([0u8; HASHLEN]);
     noise.get_ask(hmac, LABEL_RATCHET_STATE, &mut rk, &mut rf);
-    RatchetState::new(Zeroizing::new(rk[..RATCHET_SIZE].try_into().unwrap()), Zeroizing::new(rf[..RATCHET_SIZE].try_into().unwrap()), pre_chain_len + 1)
+    RatchetState::new(
+        Zeroizing::new(rk[..RATCHET_SIZE].try_into().unwrap()),
+        Zeroizing::new(rf[..RATCHET_SIZE].try_into().unwrap()),
+        pre_chain_len + 1,
+    )
 }
 fn get_counter<App: ApplicationLayer>(session: &Session<App>, state: &MutableState<App>) -> Option<(u64, bool)> {
     if session.session_has_expired.load(Ordering::Relaxed) {
@@ -131,7 +141,10 @@ impl<App: ApplicationLayer> Default for DuplexKey<App> {
 }
 impl<App: ApplicationLayer> DuplexKey<App> {
     fn replace_nk(&mut self, nk_send: &[u8; HASHLEN], nk_recv: &[u8; HASHLEN]) {
-        self.nk = Some(App::AeadPool::new((&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap(), (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()))
+        self.nk = Some(App::AeadPool::new(
+            (&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap(),
+            (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap(),
+        ))
     }
 }
 
@@ -144,7 +157,9 @@ impl Keys {
     fn replace_kek(&mut self, kek: &[u8; HASHLEN]) {
         // We want to give rust the best chance of implementing this in a way that does
         // not leak the key on the stack.
-        self.kek.get_or_insert(Zeroizing::new([0u8; AES_256_KEY_SIZE])).copy_from_slice(&kek[..AES_256_KEY_SIZE]);
+        self.kek
+            .get_or_insert(Zeroizing::new([0u8; AES_256_KEY_SIZE]))
+            .copy_from_slice(&kek[..AES_256_KEY_SIZE]);
     }
 }
 
@@ -185,7 +200,13 @@ pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
 }
 
 impl<App: ApplicationLayer> SymmetricState<App> {
-    fn write_e<const CAP: usize>(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, rng: &Mutex<App::Rng>, packet: &mut ArrayVec<u8, CAP>) -> App::KeyPair {
+    fn write_e<const CAP: usize>(
+        &mut self,
+        hash: &mut App::Hash,
+        hmac: &mut App::HmacHash,
+        rng: &Mutex<App::Rng>,
+        packet: &mut ArrayVec<u8, CAP>,
+    ) -> App::KeyPair {
         let e_secret = App::KeyPair::generate(rng.lock().unwrap().deref_mut());
         let pub_key = e_secret.public_key_bytes();
         packet.extend(pub_key);
@@ -193,7 +214,13 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.mix_key(hmac, &pub_key);
         e_secret
     }
-    fn read_e(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, i: &mut usize, packet: &[u8]) -> Option<App::PublicKey> {
+    fn read_e(
+        &mut self,
+        hash: &mut App::Hash,
+        hmac: &mut App::HmacHash,
+        i: &mut usize,
+        packet: &[u8],
+    ) -> Option<App::PublicKey> {
         let j = *i + P384_PUBLIC_KEY_SIZE;
         let pub_key = &packet[*i..j];
         self.mix_hash(hash, pub_key);
@@ -238,7 +265,9 @@ fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_IV_SIZE]) {
 }
 
 fn create_a1_state<App: ApplicationLayer>(
-    hash: &mut App::Hash, hmac: &mut App::HmacHash, rng: &Mutex<App::Rng>,
+    hash: &mut App::Hash,
+    hmac: &mut App::HmacHash,
+    rng: &Mutex<App::Rng>,
     s_remote: &App::PublicKey,
     kid_recv: NonZeroU32,
     ratchet_state1: &RatchetState,
@@ -312,11 +341,21 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
 
     let hash = &mut App::Hash::new();
     let hmac = &mut App::HmacHash::new();
-    let a1 = create_a1_state(hash, hmac, &ctx.rng, &s_remote, kid_recv, &ratchet_state1, ratchet_state2.as_ref(), identity).ok_or(OpenError::InvalidPublicKey)?;
+    let a1 = create_a1_state(
+        hash,
+        hmac,
+        &ctx.rng,
+        &s_remote,
+        kid_recv,
+        &ratchet_state1,
+        ratchet_state2.as_ref(),
+        identity,
+    )
+    .ok_or(OpenError::InvalidPublicKey)?;
 
     let mut noise_kk_ss = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
     if !ctx.s_secret.agree(&s_remote, &mut noise_kk_ss) {
-        return Err(OpenError::InvalidPublicKey)
+        return Err(OpenError::InvalidPublicKey);
     }
 
     let mut hk_recv = Zeroizing::new([0u8; HASHLEN]);
@@ -359,18 +398,18 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     }
 
     session_map.insert(kid_recv, Arc::downgrade(&session));
-    session_queue.push_reserved(
-        queue_idx,
-        Arc::downgrade(&session),
-        Reverse(resend_timer),
-    );
+    session_queue.push_reserved(queue_idx, Arc::downgrade(&session), Reverse(resend_timer));
 
     send(&mut x1, None);
 
     Ok(session)
 }
 /// Corresponds to Algorithm 13 found in Section 5.
-pub(crate) fn respond_to_challenge<App: ApplicationLayer>(ctx: &Arc<ContextInner<App>>, session: &Session<App>,  challenge: &[u8; CHALLENGE_SIZE]) {
+pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
+    ctx: &Arc<ContextInner<App>>,
+    session: &Session<App>,
+    challenge: &[u8; CHALLENGE_SIZE],
+) {
     let mut state = session.state.write().unwrap();
     if let ZetaAutomata::A1(a1) = &mut state.beta {
         let response_start = a1.x1.len() - CHALLENGE_SIZE;
@@ -408,13 +447,18 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     // Noise process prologue.
     let j = i + KID_SIZE;
     noise.mix_hash(hash, &x1[i..j]);
-    let kid_send = NonZeroU32::new(u32::from_be_bytes(x1[i..j].try_into().unwrap())).ok_or(byzantine_fault!(InvalidPacket, true))?;
+    let kid_send = NonZeroU32::new(u32::from_be_bytes(x1[i..j].try_into().unwrap()))
+        .ok_or(byzantine_fault!(InvalidPacket, true))?;
     noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
     i = j;
     // Process message pattern 1 e token.
-    let e_remote = noise.read_e(hash, hmac, &mut i, &x1).ok_or(byzantine_fault!(FailedAuth, true))?;
+    let e_remote = noise
+        .read_e(hash, hmac, &mut i, &x1)
+        .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 1 es token.
-    noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    noise
+        .mix_dh(hmac, &ctx.s_secret, &e_remote)
+        .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 1 e1 token.
     let j = i + KYBER_PUBLIC_KEY_SIZE;
     let k = i + AES_GCM_TAG_SIZE;
@@ -462,12 +506,19 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     // Process message pattern 2 e token.
     let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut x2);
     // Process message pattern 2 ee token.
-    noise.mix_dh(hmac, &e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    noise
+        .mix_dh(hmac, &e_secret, &e_remote)
+        .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 2 ekem1 token.
     {
         let i = x2.len();
         let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
-        let ekem1 = App::Kem::encapsulate(ctx.rng.lock().unwrap().deref_mut(), (&x1[e1_start..e1_end]).try_into().unwrap(), &mut ekem1_secret).ok_or(byzantine_fault!(FailedAuth, true))?;
+        let ekem1 = App::Kem::encapsulate(
+            ctx.rng.lock().unwrap().deref_mut(),
+            (&x1[e1_start..e1_end]).try_into().unwrap(),
+            &mut ekem1_secret,
+        )
+        .ok_or(byzantine_fault!(FailedAuth, true))?;
         x2.extend(ekem1);
         let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]);
         x2.extend(tag);
@@ -476,7 +527,10 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     // Process message pattern 2 psk2 token.
     noise.mix_key_and_hash(hash, hmac, ratchet_state.key.as_ref());
     // Process message pattern 2 payload.
-    let kid_recv = gen_kid(ctx.session_map.read().unwrap().deref(), ctx.rng.lock().unwrap().deref_mut());
+    let kid_recv = gen_kid(
+        ctx.session_map.read().unwrap().deref(),
+        ctx.rng.lock().unwrap().deref_mut(),
+    );
 
     let i = x2.len();
     x2.extend(kid_recv.get().to_be_bytes());
@@ -504,10 +558,13 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
             noise,
             defrag: Mutex::new(Fragged::new()),
         }),
-        app.time()
+        app.time(),
     );
 
-    send(&mut x2, Some(&App::PrpEnc::new(&hk_send[..AES_256_KEY_SIZE].try_into().unwrap())));
+    send(
+        &mut x2,
+        Some(&App::PrpEnc::new(&hk_send[..AES_256_KEY_SIZE].try_into().unwrap())),
+    );
     Ok(())
 }
 /// Corresponds to Transition Algorithm 3 found in Section 4.3.
@@ -548,9 +605,13 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         let mut noise = a1.noise.clone();
         let mut i = 0;
         // Process message pattern 2 e token.
-        let e_remote = noise.read_e(hash, hmac, &mut i, &x2).ok_or(byzantine_fault!(FailedAuth, true))?;
+        let e_remote = noise
+            .read_e(hash, hmac, &mut i, &x2)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 ee token.
-        noise.mix_dh(hmac, &a1.e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise
+            .mix_dh(hmac, &a1.e_secret, &e_remote)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 ekem1 token.
         let j = i + KYBER_CIPHERTEXT_SIZE;
         let k = j + AES_GCM_TAG_SIZE;
@@ -559,7 +620,10 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             return Err(byzantine_fault!(FailedAuth, true));
         }
         let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
-        if !a1.e1_secret.decapsulate((&x2[i..j]).try_into().unwrap(), &mut ekem1_secret) {
+        if !a1
+            .e1_secret
+            .decapsulate((&x2[i..j]).try_into().unwrap(), &mut ekem1_secret)
+        {
             return Err(byzantine_fault!(FailedAuth, true));
         }
         noise.mix_key(hmac, ekem1_secret.as_ref());
@@ -618,7 +682,9 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..]);
         x3.extend(tag);
         // Process message pattern 3 se token.
-        noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise
+            .mix_dh(hmac, &ctx.s_secret, &e_remote)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 3 payload.
         let i = x3.len();
         x3.try_extend_from_slice(&a1.identity).unwrap();
@@ -676,11 +742,19 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 // This return is unreachable.
                 return Err(byzantine_fault!(FailedAuth, true));
             };
-            state.beta = ZetaAutomata::A3 { identity: a1.identity.clone(), x3: x3.clone(), kid_send: kid_send.get(), nonce };
+            state.beta = ZetaAutomata::A3 {
+                identity: a1.identity.clone(),
+                x3: x3.clone(),
+                kid_send: kid_send.get(),
+                nonce,
+            };
             resend_timer
         };
         drop(kex_lock);
-        ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(resend_timer));
+        ctx.session_queue
+            .lock()
+            .unwrap()
+            .change_priority(session.queue_idx, Reverse(resend_timer));
 
         Ok(x3)
     })();
@@ -722,10 +796,13 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..j], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let s_remote = App::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
+    let s_remote =
+        App::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
     i = k;
     // Process message pattern 3 se token.
-    noise.mix_dh(hmac, &zeta.e_secret, &s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+    noise
+        .mix_dh(hmac, &zeta.e_secret, &s_remote)
+        .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 3 payload.
     let k = x3.len();
     let j = k - AES_GCM_TAG_SIZE;
@@ -752,7 +829,12 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         let mut d = ArrayVec::<u8, HEADERED_SESSION_REJECTED_SIZE>::new();
         d.extend([0u8; HEADER_SIZE]);
         let nonce = to_nonce(PACKET_TYPE_SESSION_REJECTED, c);
-        d.extend(App::Aead::encrypt_in_place((&kek_send[..AES_256_KEY_SIZE]).try_into().unwrap(), &nonce, &[], &mut []));
+        d.extend(App::Aead::encrypt_in_place(
+            (&kek_send[..AES_256_KEY_SIZE]).try_into().unwrap(),
+            &nonce,
+            &[],
+            &mut [],
+        ));
         set_header(&mut d, zeta.kid_send.get(), &nonce);
         d
     };
@@ -891,7 +973,12 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(OutOfSequence, false));
     };
 
-    let specified_key = state.key_ref(is_other).recv.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let specified_key = state
+        .key_ref(is_other)
+        .recv
+        .kek
+        .as_ref()
+        .ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = c1[..].try_into().unwrap();
     if !App::Aead::decrypt_in_place(specified_key, n, &[], &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
@@ -928,13 +1015,17 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
                 state.timeout_timer = app.time()
                     + App::SETTINGS
                         .rekey_after_time
-                        .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+                        .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter)
+                        as i64;
                 state.resend_timer = AtomicI64::new(i64::MAX);
                 state.beta = ZetaAutomata::S2;
                 state.timeout_timer
             };
             drop(kex_lock);
-            ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timeout_timer));
+            ctx.session_queue
+                .lock()
+                .unwrap()
+                .change_priority(session.queue_idx, Reverse(timeout_timer));
             state = session.state.read().unwrap();
         }
     }
@@ -943,9 +1034,18 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     c2.extend([0u8; HEADER_SIZE]);
     let (c, _) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
     let nonce = to_nonce(PACKET_TYPE_ACK, c);
-    let latest_confirmed_key = state.key_ref(false).send.kek.as_ref().ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let latest_confirmed_key = state
+        .key_ref(false)
+        .send
+        .kek
+        .as_ref()
+        .ok_or(byzantine_fault!(OutOfSequence, true))?;
     c2.extend(App::Aead::encrypt_in_place(latest_confirmed_key, &nonce, &[], &mut []));
-    let kid_send = state.key_ref(false).send.kid.ok_or(byzantine_fault!(OutOfSequence, false))?;
+    let kid_send = state
+        .key_ref(false)
+        .send
+        .kid
+        .ok_or(byzantine_fault!(OutOfSequence, false))?;
     set_header(&mut c2, kid_send.get(), &nonce);
 
     send(&mut c2, Some(&session.hk_send));
@@ -993,13 +1093,17 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
         state.timeout_timer = app.time()
             + App::SETTINGS
                 .rekey_after_time
-                .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter) as i64;
+                .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter)
+                as i64;
         state.resend_timer = AtomicI64::new(i64::MAX);
         state.beta = ZetaAutomata::S2;
         state.timeout_timer
     };
     drop(kex_lock);
-    ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timeout_timer));
+    ctx.session_queue
+        .lock()
+        .unwrap()
+        .change_priority(session.queue_idx, Reverse(timeout_timer));
     Ok(())
 }
 /// Corresponds to the trivial Transition Algorithm described for processing D packets found in
@@ -1086,8 +1190,12 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
                     drop(state);
                     let resend_timer = {
                         let mut state = session.state.write().unwrap();
-                        session.hk_recv.reset((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap());
-                        session.hk_send.reset((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap());
+                        session
+                            .hk_recv
+                            .reset((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap());
+                        session
+                            .hk_send
+                            .reset((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap());
                         *state.key_mut(true) = DuplexKey::default();
                         state.key_mut(true).recv.kid = Some(new_kid_recv);
                         let resend_timer = current_time + App::SETTINGS.resend_time as i64;
@@ -1151,7 +1259,12 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
 
                 if let Some((c, _)) = get_counter(session, &state) {
                     let nonce = to_nonce(PACKET_TYPE_REKEY_INIT, c);
-                    let tag = App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut k1);
+                    let tag = App::Aead::encrypt_in_place(
+                        state.key_ref(false).send.kek.as_ref().unwrap(),
+                        &nonce,
+                        &[],
+                        &mut k1,
+                    );
                     k1.extend(tag);
                     set_header(&mut k1, state.key_ref(false).send.kid.unwrap().get(), &nonce);
 
@@ -1208,9 +1321,18 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
             };
             if let Some((c, _)) = get_counter(session, &state) {
                 let nonce = to_nonce(packet_type, c);
-                let tag = App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut control_payload);
+                let tag = App::Aead::encrypt_in_place(
+                    state.key_ref(false).send.kek.as_ref().unwrap(),
+                    &nonce,
+                    &[],
+                    &mut control_payload,
+                );
                 control_payload.extend(tag);
-                set_header(&mut control_payload, state.key_ref(false).send.kid.unwrap().get(), &nonce);
+                set_header(
+                    &mut control_payload,
+                    state.key_ref(false).send.kid.unwrap().get(),
+                    &nonce,
+                );
 
                 send(&mut control_payload, Some(&session.hk_send));
             }
@@ -1220,7 +1342,11 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
         }
     }
 }
-fn remap<App: ApplicationLayer>(ctx: &Arc<ContextInner<App>>, session: &Arc<Session<App>>, state: &MutableState<App>) -> NonZeroU32 {
+fn remap<App: ApplicationLayer>(
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
+    state: &MutableState<App>,
+) -> NonZeroU32 {
     let mut session_map = ctx.session_map.write().unwrap();
     let weak = if let Some(Some(weak)) = state.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
         weak
@@ -1270,7 +1396,13 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 
     let i = k1.len() - AES_GCM_TAG_SIZE;
     let tag = k1[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut k1[..i], &tag) {
+    if !App::Aead::decrypt_in_place(
+        state.key_ref(false).recv.kek.as_ref().unwrap(),
+        n,
+        &[],
+        &mut k1[..i],
+        &tag,
+    ) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
@@ -1289,9 +1421,13 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         // Process message pattern 1 psk0 token.
         noise.mix_key_and_hash(hash, hmac, state.ratchet_state1.key.as_ref());
         // Process message pattern 1 e token.
-        let e_remote = noise.read_e(hash, hmac, &mut i, &k1).ok_or(byzantine_fault!(FailedAuth, true))?;
+        let e_remote = noise
+            .read_e(hash, hmac, &mut i, &k1)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 es token.
-        noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise
+            .mix_dh(hmac, &ctx.s_secret, &e_remote)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 ss token.
         noise.mix_key(hmac, session.noise_kk_ss.as_ref());
         // Process message pattern 1 payload.
@@ -1301,16 +1437,21 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..j], tag) {
             return Err(byzantine_fault!(FailedAuth, true));
         }
-        let kid_send = NonZeroU32::new(u32::from_be_bytes(k1[i..j].try_into().unwrap())).ok_or(byzantine_fault!(FailedAuth, true))?;
+        let kid_send = NonZeroU32::new(u32::from_be_bytes(k1[i..j].try_into().unwrap()))
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
 
         let mut k2 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
         k2.extend([0u8; HEADER_SIZE]);
         // Process message pattern 2 e token.
         let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut k2);
         // Process message pattern 2 ee token.
-        noise.mix_dh(hmac, &e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise
+            .mix_dh(hmac, &e_secret, &e_remote)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 se token.
-        noise.mix_dh(hmac, &ctx.s_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+        noise
+            .mix_dh(hmac, &ctx.s_secret, &e_remote)
+            .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 payload.
         let i = k2.len();
         let new_kid_recv = remap(ctx, session, &state);
@@ -1360,7 +1501,10 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
             resend_timer
         };
         drop(kex_lock);
-        ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(resend_timer));
+        ctx.session_queue
+            .lock()
+            .unwrap()
+            .change_priority(session.queue_idx, Reverse(resend_timer));
         let state = session.state.read().unwrap();
 
         let (c, _) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
@@ -1408,7 +1552,13 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
 
     let i = k2.len() - AES_GCM_TAG_SIZE;
     let tag = k2[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut k2[..i], &tag) {
+    if !App::Aead::decrypt_in_place(
+        state.key_ref(false).recv.kek.as_ref().unwrap(),
+        n,
+        &[],
+        &mut k2[..i],
+        &tag,
+    ) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
@@ -1422,11 +1572,17 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             let hash = &mut App::Hash::new();
             let hmac = &mut App::HmacHash::new();
             // Process message pattern 2 e token.
-            let e_remote = noise.read_e(hash, hmac, &mut i, &k2).ok_or(byzantine_fault!(FailedAuth, true))?;
+            let e_remote = noise
+                .read_e(hash, hmac, &mut i, &k2)
+                .ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 ee token.
-            noise.mix_dh(hmac, e_secret, &e_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            noise
+                .mix_dh(hmac, e_secret, &e_remote)
+                .ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 se token.
-            noise.mix_dh(hmac, e_secret, &session.s_remote).ok_or(byzantine_fault!(FailedAuth, true))?;
+            noise
+                .mix_dh(hmac, e_secret, &session.s_remote)
+                .ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 payload.
             let j = i + KID_SIZE;
             let k = j + AES_GCM_TAG_SIZE;
@@ -1434,7 +1590,8 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..j], tag) {
                 return Err(byzantine_fault!(FailedAuth, true));
             }
-            let kid_send = NonZeroU32::new(u32::from_be_bytes(k2[i..j].try_into().unwrap())).ok_or(byzantine_fault!(InvalidPacket, true))?;
+            let kid_send = NonZeroU32::new(u32::from_be_bytes(k2[i..j].try_into().unwrap()))
+                .ok_or(byzantine_fault!(InvalidPacket, true))?;
 
             let new_ratchet_state = create_ratchet_state(hmac, &noise, state.ratchet_state1.chain_len);
             let result = app.save_ratchet_state(
@@ -1476,7 +1633,10 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
                 (current_time, resend_timer)
             };
             drop(kex_lock);
-            ctx.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(resend_timer));
+            ctx.session_queue
+                .lock()
+                .unwrap()
+                .change_priority(session.queue_idx, Reverse(resend_timer));
             process_timers(app, ctx, session, current_time, false, true, send);
 
             Ok(())
@@ -1512,9 +1672,12 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
         return Err(byzantine_fault!(OutOfSequence, true));
     };
 
-    let mut cipher = state.key_ref(is_other).nk
+    let mut cipher = state
+        .key_ref(is_other)
+        .nk
         .as_ref()
-        .ok_or(byzantine_fault!(OutOfSequence, true))?.start_dec(n);
+        .ok_or(byzantine_fault!(OutOfSequence, true))?
+        .start_dec(n);
 
     // NOTE: This only works because we check the size of every received fragment in the receive
     // function, otherwise this could panic.
@@ -1549,7 +1712,6 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
     Ok(())
 }
 
-
 impl<App: ApplicationLayer> Drop for Session<App> {
     fn drop(&mut self) {
         self.expire();
@@ -1562,7 +1724,11 @@ impl<App: ApplicationLayer> Session<App> {
     pub fn expire(&self) {
         self.expire_inner(self.state_machine_lock.lock().unwrap(), self.state.write().unwrap());
     }
-    pub(crate) fn expire_inner(&self, kex_lock: MutexGuard<'_, ()>, mut state: RwLockWriteGuard<'_, MutableState<App>>) {
+    pub(crate) fn expire_inner(
+        &self,
+        kex_lock: MutexGuard<'_, ()>,
+        mut state: RwLockWriteGuard<'_, MutableState<App>>,
+    ) {
         let mut kids_to_remove = None;
         if !matches!(&state.beta, ZetaAutomata::Null) {
             self.session_has_expired.store(true, Ordering::Relaxed);
@@ -1630,7 +1796,10 @@ impl<App: ApplicationLayer> Session<App> {
     /// Check whether this session is established.
     pub fn established(&self) -> bool {
         let state = self.state.read().unwrap();
-        !matches!(&state.beta, ZetaAutomata::A1(_) | ZetaAutomata::A3 {..} | ZetaAutomata::Null)
+        !matches!(
+            &state.beta,
+            ZetaAutomata::A1(_) | ZetaAutomata::A3 { .. } | ZetaAutomata::Null
+        )
     }
     /// The static public key of the remote peer.
     pub fn remote_static_key(&self) -> &App::PublicKey {
diff --git a/src/zssp.rs b/src/zssp.rs
index 5af962f..fac5118 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -10,8 +10,8 @@
 
 use std::cmp::Reverse;
 use std::collections::HashMap;
-use std::io::Write;
 use std::hash::Hash;
+use std::io::Write;
 use std::num::{NonZeroU32, NonZeroU64};
 use std::ops::DerefMut;
 use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
@@ -20,21 +20,21 @@ use std::sync::{Arc, Mutex, MutexGuard, RwLock, Weak};
 use arrayvec::ArrayVec;
 use zeroize::Zeroizing;
 
-use crate::zeta::*;
 use crate::challenge::ChallengeContext;
-use crate::crypto::aes::{AesDec, AesEnc, AES_256_KEY_SIZE, AES_GCM_TAG_SIZE, AES_GCM_IV_SIZE};
+use crate::crypto::aes::{AesDec, AesEnc, AES_256_KEY_SIZE, AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE};
 use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
 use crate::crypto::pqc_kyber::KYBER_SECRETKEYBYTES;
 use crate::crypto::rand_core::RngCore;
-use crate::crypto::sha512::{HmacSha512, HashSha512};
+use crate::crypto::sha512::{HashSha512, HmacSha512};
+use crate::zeta::*;
 
-use crate::result::{FaultType, OpenError, ReceiveError, SendError, ReceiveOk, byzantine_fault, SessionEvent};
 use crate::frag_cache::UnassociatedFragCache;
 use crate::fragged::{Assembled, Fragged};
 use crate::handshake_cache::UnassociatedHandshakeCache;
 use crate::indexed_heap::{BinaryHeapIndex, IndexedBinaryHeap};
 use crate::log_event::LogEvent;
 use crate::proto::*;
+use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError, SessionEvent};
 use crate::symmetric_state::SymmetricState;
 use crate::{applicationlayer::*, RatchetState};
 
@@ -82,7 +82,9 @@ pub enum IncomingSessionAction {
     Drop,
 }
 
-fn parse_fragment_header<StorageError>(incoming_fragment: &[u8]) -> Result<(usize, usize, [u8; AES_GCM_IV_SIZE]), ReceiveError<StorageError>> {
+fn parse_fragment_header<StorageError>(
+    incoming_fragment: &[u8],
+) -> Result<(usize, usize, [u8; AES_GCM_IV_SIZE]), ReceiveError<StorageError>> {
     let fragment_no = incoming_fragment[FRAGMENT_NO_IDX] as usize;
     let fragment_count = incoming_fragment[FRAGMENT_COUNT_IDX] as usize;
     if fragment_no >= fragment_count || fragment_count > MAX_FRAGMENTS {
@@ -93,7 +95,6 @@ fn parse_fragment_header<StorageError>(incoming_fragment: &[u8]) -> Result<(usiz
     Ok((fragment_no, fragment_count, nonce))
 }
 
-
 /// Fragments and sends the packet, destroying it in the process.
 ///
 /// Corresponds to the fragmentation algorithm described in Section 6.
@@ -119,9 +120,7 @@ fn send_with_fragmentation<PrpEnc: AesEnc>(
         fragment[FRAGMENT_COUNT_IDX] = fragment_count as u8;
 
         if let Some(hk_send) = hk_send {
-            hk_send.encrypt_in_place(
-                (&mut fragment[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap(),
-            );
+            hk_send.encrypt_in_place((&mut fragment[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap());
         }
         if !send(fragment) {
             return false;
@@ -184,7 +183,7 @@ impl<App: ApplicationLayer> Context<App> {
             identity,
             |packet, hk_send| {
                 send_with_fragmentation(send, mtu, packet, hk_send);
-            }
+            },
         )
     }
 
@@ -256,7 +255,8 @@ impl<App: ApplicationLayer> Context<App> {
                 let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
                 let (packet_type, incoming_counter) = from_nonce(&nonce);
 
-                {//vrfy
+                {
+                    //vrfy
                     if packet_type != PACKET_TYPE_DATA {
                         log!(app, ReceivedRawFragment(p, c, fragment_no, fragment_count));
                     }
@@ -332,7 +332,9 @@ impl<App: ApplicationLayer> Context<App> {
                             return Ok(ReceiveOk::Unassociated);
                         } else {
                             for fragment in fragment_buffer.as_ref() {
-                                buffer.try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..]).map_err(|_| byzantine_fault!(InvalidPacket, true))?;
+                                buffer
+                                    .try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..])
+                                    .map_err(|_| byzantine_fault!(InvalidPacket, true))?;
                             }
                             // We have not yet authenticated the sender so we do not report
                             // receiving a packet from them.
@@ -351,7 +353,13 @@ impl<App: ApplicationLayer> Context<App> {
                     match packet_type {
                         PACKET_TYPE_HANDSHAKE_RESPONSE => {
                             log!(app, ReceivedRawX2);
-                            received_x2_trans(
+                            received_x2_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet, send_associated)?;
+                            log!(app, X2IsAuthSentX3(&session));
+                            SessionEvent::Control
+                        }
+                        PACKET_TYPE_KEY_CONFIRM => {
+                            log!(app, ReceivedRawKeyConfirm);
+                            let result = received_c1_trans(
                                 app,
                                 ctx,
                                 &session,
@@ -360,13 +368,6 @@ impl<App: ApplicationLayer> Context<App> {
                                 assembled_packet,
                                 send_associated,
                             )?;
-                            log!(app, X2IsAuthSentX3(&session));
-                            SessionEvent::Control
-                        }
-                        PACKET_TYPE_KEY_CONFIRM => {
-                            log!(app, ReceivedRawKeyConfirm);
-                            let result =
-                                received_c1_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet,send_associated)?;
                             log!(app, KeyConfirmIsAuthSentAck(&session));
                             if result {
                                 SessionEvent::Established
@@ -416,10 +417,14 @@ impl<App: ApplicationLayer> Context<App> {
                     let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
                     let (packet_type, incoming_counter) = from_nonce(&nonce);
 
-                    {//vrfy
-                        log!(app, ReceivedRawFragment(packet_type, incoming_counter, frag_no, frag_count));
+                    {
+                        //vrfy
+                        log!(
+                            app,
+                            ReceivedRawFragment(packet_type, incoming_counter, frag_no, frag_count)
+                        );
                         if packet_type != PACKET_TYPE_HANDSHAKE_COMPLETION || incoming_counter != 0 {
-                            return Err(byzantine_fault!(InvalidPacket, true))
+                            return Err(byzantine_fault!(InvalidPacket, true));
                         }
                     }
 
@@ -430,13 +435,15 @@ impl<App: ApplicationLayer> Context<App> {
                             incoming_fragment_buf,
                             fragment_no,
                             fragment_count,
-                            &mut fragment_buffer
+                            &mut fragment_buffer,
                         );
                         if fragment_buffer.is_empty() {
                             return Ok(ReceiveOk::Unassociated);
                         } else {
                             for fragment in fragment_buffer.as_ref() {
-                                buffer.try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..]).map_err(|_| byzantine_fault!(InvalidPacket, true))?;
+                                buffer
+                                    .try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..])
+                                    .map_err(|_| byzantine_fault!(InvalidPacket, true))?;
                             }
                             buffer.as_mut()
                         }
@@ -451,12 +458,7 @@ impl<App: ApplicationLayer> Context<App> {
 
                     log!(app, ReceivedRawX3);
                     let session = received_x3_trans(app, ctx, zeta, kid_recv, assembled_packet, |packet, hk_send| {
-                        send_with_fragmentation(
-                            send_unassociated_reply,
-                            send_unassociated_mtu,
-                            packet,
-                            hk_send,
-                        );
+                        send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
                     })?;
                     log!(app, X3IsAuthSentKeyConfirm(&session));
                     Ok(ReceiveOk::Session(session, SessionEvent::NewSession))
@@ -471,10 +473,11 @@ impl<App: ApplicationLayer> Context<App> {
             let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
             let (packet_type, _c) = from_nonce(&nonce);
 
-            {//vrfy
+            {
+                //vrfy
                 log!(app, ReceivedRawFragment(packet_type, _c, frag_no, frag_count));
                 if packet_type != PACKET_TYPE_HANDSHAKE_HELLO && packet_type != PACKET_TYPE_CHALLENGE {
-                    return Err(byzantine_fault!(InvalidPacket, true))
+                    return Err(byzantine_fault!(InvalidPacket, true));
                 }
             }
 
@@ -489,13 +492,15 @@ impl<App: ApplicationLayer> Context<App> {
                     fragment_count,
                     App::SETTINGS.resend_time as i64,
                     app.time(),
-                    &mut fragment_buffer
+                    &mut fragment_buffer,
                 );
                 if fragment_buffer.is_empty() {
                     return Ok(ReceiveOk::Unassociated);
                 } else {
                     for fragment in fragment_buffer.as_ref() {
-                        buffer.try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..]).map_err(|_| byzantine_fault!(InvalidPacket, true))?;
+                        buffer
+                            .try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..])
+                            .map_err(|_| byzantine_fault!(InvalidPacket, true))?;
                     }
                     buffer.as_mut()
                 }
@@ -506,17 +511,24 @@ impl<App: ApplicationLayer> Context<App> {
             if packet_type == PACKET_TYPE_HANDSHAKE_HELLO {
                 log!(app, ReceivedRawX1);
 
-                if !(HANDSHAKE_HELLO_CHALLENGE_MIN_SIZE..=HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE).contains(&assembled_packet.len()) {
+                if !(HANDSHAKE_HELLO_CHALLENGE_MIN_SIZE..=HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE)
+                    .contains(&assembled_packet.len())
+                {
                     return Err(byzantine_fault!(InvalidPacket, true));
                 }
                 // Process recv challenge layer.
                 let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
-                let result = ctx.challenge.process_hello::<App::Hash>(remote_address, (&assembled_packet[challenge_start..]).try_into().unwrap());
+                let result = ctx.challenge.process_hello::<App::Hash>(
+                    remote_address,
+                    (&assembled_packet[challenge_start..]).try_into().unwrap(),
+                );
                 if let Err(challenge) = result {
                     log!(app, X1FailedChallengeSentNewChallenge);
                     let mut challenge_packet = ArrayVec::<u8, HEADERED_CHALLENGE_SIZE>::new();
                     challenge_packet.extend([0u8; HEADER_SIZE]);
-                    challenge_packet.try_extend_from_slice(&assembled_packet[..KID_SIZE]).unwrap();
+                    challenge_packet
+                        .try_extend_from_slice(&assembled_packet[..KID_SIZE])
+                        .unwrap();
                     challenge_packet.extend(challenge);
                     let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
                     challenge_packet[FRAGMENT_COUNT_IDX] = 1;
@@ -531,12 +543,7 @@ impl<App: ApplicationLayer> Context<App> {
 
                 // Process recv zeta layer.
                 received_x1_trans(app, ctx, &nonce, assembled_packet, |packet, hk_send| {
-                    send_with_fragmentation(
-                        send_unassociated_reply,
-                        send_unassociated_mtu,
-                        packet,
-                        hk_send,
-                    );
+                    send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
                 })?;
                 log!(app, X1IsAuthSentX2);
 
@@ -547,7 +554,9 @@ impl<App: ApplicationLayer> Context<App> {
                 if assembled_packet.len() != KID_SIZE + CHALLENGE_SIZE {
                     return Err(byzantine_fault!(InvalidPacket, true));
                 }
-                if let Some(kid_recv) = NonZeroU32::new(u32::from_be_bytes(assembled_packet[..KID_SIZE].try_into().unwrap())) {
+                if let Some(kid_recv) =
+                    NonZeroU32::new(u32::from_be_bytes(assembled_packet[..KID_SIZE].try_into().unwrap()))
+                {
                     if let Some(Some(session)) = ctx.session_map.read().unwrap().get(&kid_recv).map(|r| r.upgrade()) {
                         respond_to_challenge(ctx, &session, &assembled_packet[KID_SIZE..].try_into().unwrap());
                         log!(app, ChallengeIsAuth(&session));

From 2a7784b5226bce33fdb6abdac33dca80ce6891b1 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 7 Aug 2023 23:07:16 -0400
Subject: [PATCH 19/50] cargo fmt

---
 src/applicationlayer.rs |   2 +-
 src/handshake_cache.rs  |   2 +-
 src/lib.rs              |  16 +--
 src/log_event.rs        |   2 +-
 src/proto.rs            |   1 -
 src/zeta.rs             | 125 +++++++++++++++++-----
 src/zssp.rs             | 227 ++++++----------------------------------
 7 files changed, 142 insertions(+), 233 deletions(-)

diff --git a/src/applicationlayer.rs b/src/applicationlayer.rs
index 4d7fcfc..f078770 100644
--- a/src/applicationlayer.rs
+++ b/src/applicationlayer.rs
@@ -14,7 +14,7 @@ use crate::crypto::rand_core::{CryptoRng, RngCore};
 use crate::crypto::sha512::{HashSha512, HmacSha512};
 use crate::proto::RATCHET_SIZE;
 use crate::zeta::Session;
-use crate::RatchetState;
+use crate::ratchet_state::RatchetState;
 //use crate::{log_event::LogEvent, Session};
 
 /// A container for a vast majority of the dynamic settings within ZSSP, including all time-based settings.
diff --git a/src/handshake_cache.rs b/src/handshake_cache.rs
index 8ce3852..1344412 100644
--- a/src/handshake_cache.rs
+++ b/src/handshake_cache.rs
@@ -11,7 +11,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock};
 
 use crate::zeta::StateB2;
-use crate::{proto::MAX_UNASSOCIATED_HANDSHAKE_STATES, ApplicationLayer};
+use crate::{proto::MAX_UNASSOCIATED_HANDSHAKE_STATES, applicationlayer::ApplicationLayer};
 
 pub(crate) struct UnassociatedHandshakeCache<Application: ApplicationLayer> {
     has_pending: AtomicBool, // Allowed to be falsely positive
diff --git a/src/lib.rs b/src/lib.rs
index 44a6e59..358dc61 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -8,24 +8,24 @@
 pub mod crypto;
 
 mod antireplay;
-mod applicationlayer;
+pub mod applicationlayer;
 mod challenge;
 mod frag_cache;
 mod fragged;
 mod handshake_cache;
 mod indexed_heap;
-mod log_event;
-mod proto;
-mod ratchet_state;
+pub mod log_event;
+pub mod proto;
+pub mod ratchet_state;
 pub mod result;
 mod symmetric_state;
-mod zeta;
-mod zssp;
+pub mod zeta;
+pub mod zssp;
 //mod context;
 
 //pub mod error;
-pub use crate::applicationlayer::ApplicationLayer;
+//pub use crate::applicationlayer::ApplicationLayer;
 //pub use crate::log_event::LogEvent;
 //pub use crate::proto::{MAX_IDENTITY_BLOB_SIZE, MIN_PACKET_SIZE, MIN_TRANSPORT_MTU, RATCHET_SIZE};
-pub use crate::ratchet_state::RatchetState;
+//pub use crate::ratchet_state::RatchetState;
 //pub use crate::zssp::{Context, ContextInner, IncomingSessionAction, ReceiveResult, Session, SessionEvent};
diff --git a/src/log_event.rs b/src/log_event.rs
index 8690bf9..43fdc32 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -7,7 +7,7 @@
  */
 use std::sync::Arc;
 
-use crate::{zeta::Session, ApplicationLayer};
+use crate::{zeta::Session, applicationlayer::ApplicationLayer};
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
 pub enum LogEvent<'a, Application: ApplicationLayer> {
diff --git a/src/proto.rs b/src/proto.rs
index d7d5eaf..91ea301 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -92,7 +92,6 @@ pub(crate) const LABEL_RATCHET_STATE: &[u8; 4] = b"ASKR";
 pub(crate) const LABEL_HEADER_KEY: &[u8; 4] = b"ASKH";
 pub(crate) const LABEL_KEX_KEY: &[u8; 4] = b"ASKK";
 
-pub(crate) const INIT_COUNTER: u64 = 0;
 pub(crate) const EXPIRE_AFTER_USES: u64 = 1 << 32 - 1;
 /// Determines the number of counters a session will remember. If a counter arrives over
 /// this amount out of order relative to other received counters, it is likely to be
diff --git a/src/zeta.rs b/src/zeta.rs
index f0b0c4a..79e7eba 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -6,14 +6,14 @@ use std::io::Write;
 use std::num::NonZeroU32;
 use std::ops::{Deref, DerefMut};
 use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
-use std::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockWriteGuard, Weak};
+use std::sync::{Arc, Mutex, RwLock, Weak};
 use zeroize::Zeroizing;
 
 use crate::antireplay::Window;
 use crate::applicationlayer::ApplicationLayer;
 use crate::applicationlayer::RatchetUpdate;
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
-use crate::zssp::{log, ContextInner};
+use crate::zssp::{log, ContextInner, SessionQueue};
 //use crate::context::{log, ContextInner, SessionMap};
 use crate::crypto::aes::*;
 use crate::crypto::kyber1024::{
@@ -25,7 +25,7 @@ use crate::fragged::Fragged;
 use crate::indexed_heap::BinaryHeapIndex;
 use crate::proto::*;
 use crate::ratchet_state::RatchetState;
-use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError};
+use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
 use crate::symmetric_state::SymmetricState;
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
@@ -71,8 +71,12 @@ fn get_counter<App: ApplicationLayer>(session: &Session<App>, state: &MutableSta
         None
     } else {
         let c = session.send_counter.fetch_add(1, Ordering::Relaxed);
+        if c > state.key_creation_counter + EXPIRE_AFTER_USES {
+            session.session_has_expired.store(true, Ordering::SeqCst);
+            return None;
+        }
         if c > THREAD_SAFE_COUNTER_HARD_EXPIRE {
-            session.session_has_expired.store(true, Ordering::SeqCst)
+            session.session_has_expired.store(true, Ordering::SeqCst);
         }
         Some((c, c > state.key_creation_counter + App::SETTINGS.rekey_after_key_uses))
     }
@@ -1109,8 +1113,6 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
 /// Corresponds to the trivial Transition Algorithm described for processing D packets found in
 /// Section 4.3.
 pub(crate) fn received_d_trans<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_IV_SIZE],
@@ -1137,8 +1139,10 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     if !session.window.update(c) {
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
+
     drop(state);
-    session.expire_inner(kex_lock, session.state.write().unwrap());
+    drop(kex_lock);
+    session.expire();
     Ok(())
 }
 /// Corresponds to the timer rules of the Zeta State Machine found in Section 4.1 - Definition 3.
@@ -1152,7 +1156,7 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Option<i64> {
     let kex_lock = session.state_machine_lock.lock().unwrap();
-    let mut state = session.state.read().unwrap();
+    let state = session.state.read().unwrap();
     if force_timeout || state.timeout_timer <= current_time {
         // Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
         match &state.beta {
@@ -1221,8 +1225,8 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
                 //    ...
                 //    -> psk, e, es, ss
                 let mut noise = SymmetricState::initialize(PROTOCOL_NAME_NOISE_KK);
-                let mut hash = &mut App::Hash::new();
-                let mut hmac = &mut App::HmacHash::new();
+                let hash = &mut App::Hash::new();
+                let hmac = &mut App::HmacHash::new();
                 let mut k1 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
                 k1.extend([0u8; HEADER_SIZE]);
                 // Noise process prologue.
@@ -1650,10 +1654,77 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     }
     result
 }
+/// Corresponds to Algorithm 9 found in Section 4.3.
+pub(crate) fn send_payload<App: ApplicationLayer>(
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
+    payload: &[u8],
+    mut send: impl FnMut(&[u8]) -> bool,
+    mtu_sized_buffer: &mut [u8],
+) -> Result<(), SendError> {
+    use SendError::*;
+    let mtu = mtu_sized_buffer.len();
+    if mtu < MIN_TRANSPORT_MTU {
+        return Err(InvalidParameter);
+    }
+
+    let state = session.state.read().unwrap();
+    if matches!(&state.beta, ZetaAutomata::Null) {
+        return Err(SessionExpired);
+    }
+    if !matches!(
+        &state.beta,
+        ZetaAutomata::S1 | ZetaAutomata::S2 | ZetaAutomata::R1 { .. } | ZetaAutomata::R2 { .. }
+    ) {
+        return Err(SessionNotEstablished);
+    }
+    let (c, should_rekey) = get_counter(session, &state).ok_or(SessionExpired)?;
+    let nonce = to_nonce(PACKET_TYPE_DATA, c);
+
+    let key = state.key_ref(false);
+    let mut cipher = key.nk.as_ref().unwrap().start_enc(&nonce);
+
+    let payload_mtu = mtu - HEADER_SIZE;
+    debug_assert!(payload_mtu >= 4);
+    let fragment_count = payload.len().saturating_add(payload_mtu - 1) / payload_mtu; // Ceiling div.
+    let fragment_base_size = payload.len() / fragment_count;
+    let fragment_size_remainder = payload.len() % fragment_count;
+
+    mtu_sized_buffer[..KID_SIZE].copy_from_slice(&key.send.kid.unwrap().get().to_be_bytes());
+    mtu_sized_buffer[FRAGMENT_COUNT_IDX] = fragment_count as u8;
+    mtu_sized_buffer[PACKET_NONCE_START..].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
+
+    let mut i = 0;
+    for fragment_no in 0..fragment_count {
+        let fragment_len = fragment_base_size + (fragment_no < fragment_size_remainder) as usize;
+        let j = i + fragment_len;
+
+        mtu_sized_buffer[FRAGMENT_NO_IDX] = fragment_no as u8;
+        cipher.encrypt(&payload[i..j], &mut mtu_sized_buffer[HEADER_SIZE..HEADER_SIZE + fragment_len]);
+
+        session.hk_send.encrypt_in_place((&mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap());
+
+        if !send(&mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
+            return Ok(());
+        }
+        i = j;
+    }
+    drop(cipher);
+    drop(state);
+
+    if should_rekey {
+        let mut state = session.state.write().unwrap();
+        state.timeout_timer = i64::MIN;
+        drop(state);
+        ctx.session_queue
+            .lock()
+            .unwrap()
+            .change_priority(session.queue_idx, Reverse(i64::MIN));
+    }
+    Ok(())
+}
 /// Corresponds to Algorithm 10 found in Section 4.3.
 pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_IV_SIZE],
@@ -1662,7 +1733,6 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
 
-    let kex_lock = session.state_machine_lock.lock().unwrap();
     let state = session.state.read().unwrap();
     let is_other = if Some(kid) == state.key_ref(true).recv.kid {
         true
@@ -1722,13 +1792,20 @@ impl<App: ApplicationLayer> Session<App> {
     /// receive or send data or control packets. It is recommended to simply `drop` the session
     /// instead, but this can provide some reassurance in complex shared ownership situations.
     pub fn expire(&self) {
-        self.expire_inner(self.state_machine_lock.lock().unwrap(), self.state.write().unwrap());
+        if let Some(ctx) = self.ctx.upgrade() {
+            self.expire_inner(Some(&ctx), Some(&mut ctx.session_queue.lock().unwrap()));
+        } else {
+            self.expire_inner(None, None);
+        }
     }
+    /// Allows us to expire sessions with the correct locking order, preventing deadlock.
     pub(crate) fn expire_inner(
         &self,
-        kex_lock: MutexGuard<'_, ()>,
-        mut state: RwLockWriteGuard<'_, MutableState<App>>,
+        ctx: Option<&Arc<ContextInner<App>>>,
+        session_queue: Option<&mut SessionQueue<App>>,
     ) {
+        let _kex_lock = self.state_machine_lock.lock().unwrap();
+        let mut state = self.state.write().unwrap();
         let mut kids_to_remove = None;
         if !matches!(&state.beta, ZetaAutomata::Null) {
             self.session_has_expired.store(true, Ordering::Relaxed);
@@ -1738,15 +1815,13 @@ impl<App: ApplicationLayer> Session<App> {
             state.timeout_timer = i64::MAX;
             state.beta = ZetaAutomata::Null;
         }
-        drop(state);
-        drop(kex_lock);
-        if let Some(kids_to_remove) = kids_to_remove {
-            if let Some(ctx) = self.ctx.upgrade() {
-                ctx.session_queue.lock().unwrap().remove(self.queue_idx);
-                let mut session_map = ctx.session_map.write().unwrap();
-                for kid_recv in kids_to_remove.iter().flatten() {
-                    session_map.remove(kid_recv);
-                }
+        if let Some(session_queue) = session_queue {
+            session_queue.remove(self.queue_idx);
+        }
+        if let (Some(ctx), Some(kids_to_remove)) = (ctx, kids_to_remove) {
+            let mut session_map = ctx.session_map.write().unwrap();
+            for kid_recv in kids_to_remove.iter().flatten() {
+                session_map.remove(kid_recv);
             }
         }
     }
diff --git a/src/zssp.rs b/src/zssp.rs
index fac5118..b0ba9f8 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -36,7 +36,7 @@ use crate::log_event::LogEvent;
 use crate::proto::*;
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError, SessionEvent};
 use crate::symmetric_state::SymmetricState;
-use crate::{applicationlayer::*, RatchetState};
+use crate::{applicationlayer::*, ratchet_state::RatchetState};
 
 /// Macro to turn off logging at compile time.
 macro_rules! log {
@@ -315,7 +315,7 @@ impl<App: ApplicationLayer> Context<App> {
                     } else {
                         std::slice::from_mut(&mut incoming_fragment_buf)
                     };
-                    receive_payload_in_place(app, ctx, &session, kid_recv, &nonce, fragments, output_buffer)?;
+                    receive_payload_in_place(&session, kid_recv, &nonce, fragments, output_buffer)?;
                     SessionEvent::Data
                 } else {
                     let mut buffer = ArrayVec::<u8, HANDSHAKE_RESPONSE_SIZE>::new();
@@ -395,7 +395,7 @@ impl<App: ApplicationLayer> Context<App> {
                         }
                         PACKET_TYPE_SESSION_REJECTED => {
                             log!(app, ReceivedRawD);
-                            received_d_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet)?;
+                            received_d_trans(&session, kid_recv, &nonce, assembled_packet)?;
                             log!(app, DIsAuthClosedSession(&session));
                             SessionEvent::Rejected
                         }
@@ -569,7 +569,6 @@ impl<App: ApplicationLayer> Context<App> {
             }
         }
     }
-    /*
     /// Send data over the session.
     ///
     /// * `session` - The session to send to
@@ -581,70 +580,11 @@ impl<App: ApplicationLayer> Context<App> {
     pub fn send(
         &self,
         session: &Arc<Session<App>>,
-        mut send: impl FnMut(&mut [u8]) -> bool,
+        send: impl FnMut(&[u8]) -> bool,
         mtu_sized_buffer: &mut [u8],
-        mut data: &[u8],
-        current_time: i64,
+        data: &[u8],
     ) -> Result<(), SendError> {
-        if mtu_sized_buffer.len() < MIN_TRANSPORT_MTU {
-            return Err(SendError::InvalidParameter);
-        }
-        let state = session.state.read().unwrap();
-        let key = state.cipher_states[state.current_key].as_ref().ok_or(SendError::SessionNotEstablished)?;
-        let counter = session.get_next_outgoing_counter()?;
-
-        let mut c = key.get_send_cipher(counter)?;
-        c.set_iv(&create_message_nonce(PACKET_TYPE_DATA, counter));
-
-        let fragment_max_chunk_size = mtu_sized_buffer.len() - HEADER_SIZE;
-        let fragment_count = (data.len() + AES_GCM_TAG_SIZE + (fragment_max_chunk_size - 1)) / fragment_max_chunk_size;
-        if fragment_count > MAX_FRAGMENTS {
-            return Err(SendError::DataTooLarge);
-        }
-        let last_fragment_no = fragment_count - 1;
-
-        for fragment_no in 0..fragment_count {
-            let chunk_size = fragment_max_chunk_size.min(data.len());
-            let mut fragment_size = chunk_size + HEADER_SIZE;
-
-            set_packet_header(
-                mtu_sized_buffer,
-                fragment_count as u8,
-                fragment_no as u8,
-                PACKET_TYPE_DATA,
-                key.remote_key_id.get(),
-                counter,
-            );
-
-            c.encrypt(&data[..chunk_size], &mut mtu_sized_buffer[HEADER_SIZE..fragment_size]);
-            data = &data[chunk_size..];
-
-            if fragment_no == last_fragment_no {
-                debug_assert!(data.is_empty());
-                let tagged_fragment_size = fragment_size + AES_GCM_TAG_SIZE;
-                c.finish_encrypt((&mut mtu_sized_buffer[fragment_size..tagged_fragment_size]).try_into().unwrap());
-                fragment_size = tagged_fragment_size;
-            }
-
-            session.header_send_cipher.encrypt_in_place(
-                (&mut mtu_sized_buffer[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END])
-                    .try_into()
-                    .unwrap(),
-            );
-            if !send(&mut mtu_sized_buffer[..fragment_size]) {
-                break;
-            }
-        }
-        drop(c);
-        if counter >= key.rekey_at_counter {
-            if let OfferStateMachine::Normal { .. } = &state.outgoing_offer {
-                drop(state);
-                if let Ok(timer) = initiate_rekey(&self.0, session, send, current_time) {
-                    self.0.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timer));
-                }
-            }
-        }
-        Ok(())
+        send_payload(&self.0, session, data, send, mtu_sized_buffer)
     }
 
     /// Perform periodic background service and cleanup tasks.
@@ -660,20 +600,19 @@ impl<App: ApplicationLayer> Context<App> {
     ///   should rekey.
     pub fn service<SendFn: FnMut(&mut [u8]) -> bool>(
         &self,
-        app: &App,
+        app: App,
         mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
         current_time: i64,
     ) -> i64 {
-        let retry_next = current_time.saturating_add(App::RETRY_INTERVAL_MS);
-        let mut next_service_time = 2 * App::RETRY_INTERVAL_MS;
-
-        let mut session_queue = self.0.session_queue.lock().unwrap();
+        let ctx = &self.0;
+        let mut session_queue = ctx.session_queue.lock().unwrap();
+        let mut next_service_time = current_time + App::SETTINGS.fragment_assembly_timeout as i64;
         // This update system takes heavy advantage of the fact that sessions only need to be updated
         // either roughly every second or roughly every hour. That big gap allows for minor optimizations.
         // If the gap changes (unlikely) this code may need to be rewritten.
-        while let Some((session, timer, queue_idx)) = session_queue.peek() {
-            if timer.0 >= current_time {
-                next_service_time = next_service_time.min(timer.0 - current_time);
+        while let Some((session, Reverse(timer), queue_idx)) = session_queue.peek() {
+            if *timer >= current_time {
+                next_service_time = next_service_time.min(*timer);
                 break;
             }
             let session = match session.upgrade() {
@@ -683,127 +622,23 @@ impl<App: ApplicationLayer> Context<App> {
                     continue;
                 }
             };
-            let state = session.state.read().unwrap();
-            let next_timer = match &state.outgoing_offer {
-                Normal { timeout, .. } => {
-                    if *timeout <= current_time {
-                        drop(state);
-                        if let Some((send, _)) = send_to(&session) {
-                            let result = initiate_rekey(&self.0, &session, send, current_time);
-                            if result.is_ok() {
-                                app.event_log(LogEvent::ServiceKKStart(&session), current_time);
-                            }
-                            result.unwrap_or(retry_next)
-                        } else {
-                            retry_next
-                        }
-                    } else {
-                        *timeout
-                    }
+            let result = process_timers(&app, ctx, &session, current_time, false, false, |packet, hk_send| {
+                if let Some((send_fragment, mut mtu)) = send_to(&session) {
+                    mtu = mtu.max(MIN_TRANSPORT_MTU);
+                    send_with_fragmentation(
+                        send_fragment,
+                        mtu,
+                        packet,
+                        hk_send
+                    );
                 }
-                // If there's an outstanding attempt to open a session, retransmit this
-                // periodically in case the initial packet doesn't make it.
-                NoiseXKPattern1or3(handshake_state) => {
-                    if let Some(ts) = process_timer(&handshake_state.next_retry_time, App::RETRY_INTERVAL_MS, current_time) {
-                        ts
-                    } else {
-                        // We have to eventually time out NoiseXKPattern3 because of unreliable network conditions.
-                        if handshake_state.timeout <= current_time {
-                            drop(state);
-                            let _kex_lock = session.state_machine_lock.lock().unwrap();
-                            let mut state = session.state.write().unwrap();
-                            let ratchet_state = state.ratchet_states.clone();
-                            // Since we dropped the lock we must re-check if we are in the correct state.
-                            if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
-                                if handshake_state.timeout <= current_time {
-                                    app.event_log(LogEvent::ServiceXKTimeout(&session), current_time);
-                                    handshake_state.reinitialize(
-                                        &session,
-                                        &ratchet_state,
-                                        &mut self.0.session_map.write().unwrap(),
-                                        &mut self.0.rng.lock().unwrap(),
-                                        current_time,
-                                    );
-                                }
-                            }
-                        } else if let Some((mut send, mut mtu)) = send_to(&session) {
-                            mtu = mtu.max(MIN_TRANSPORT_MTU);
-                            match &handshake_state.offer {
-                                NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, message_id, .. } => {
-                                    app.event_log(LogEvent::ServiceXK1Resend(&session), current_time);
-                                    // We are in state NoiseXKPattern1 so resend noise_pattern1.
-                                    send_with_fragmentation(
-                                        &mut send,
-                                        mtu,
-                                        &mut noise_message.clone()[..*noise_message_len],
-                                        PACKET_TYPE_NOISE_XK_PATTERN_1,
-                                        None,
-                                        *message_id,
-                                        None::<&App::PrpEnc>,
-                                    );
-                                }
-                                NoiseXKAliceHandshakeState::NoiseXKPattern3 { noise_message, noise_message_len, .. } => {
-                                    app.event_log(LogEvent::ServiceXK3Resend(&session), current_time);
-                                    send_with_fragmentation(
-                                        &mut send,
-                                        mtu,
-                                        &mut noise_message.clone()[..*noise_message_len],
-                                        PACKET_TYPE_NOISE_XK_PATTERN_3,
-                                        state.cipher_states[0].as_ref().map(|k| k.remote_key_id),
-                                        0,
-                                        Some(&session.header_send_cipher),
-                                    );
-                                }
-                            }
-                        }
-                        retry_next
-                    }
-                }
-                NoiseKKPattern1 { next_retry_time, timeout, noise_message, .. } | NoiseKKPattern2 { next_retry_time, timeout, noise_message, .. } => {
-                    if let Some(ts) = process_timer(next_retry_time, App::RETRY_INTERVAL_MS, current_time) {
-                        ts
-                    } else {
-                        if *timeout <= current_time {
-                            app.event_log(LogEvent::ServiceKKTimeout(&session), current_time);
-                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
-                            drop(state);
-                            session.expire_inner(&self.0, &mut session_queue);
-                        } else {
-                            let packet_type = if let NoiseKKPattern1 { .. } = &state.outgoing_offer {
-                                app.event_log(LogEvent::ServiceKK1Resend(&session), current_time);
-                                PACKET_TYPE_NOISE_KK_PATTERN_1
-                            } else {
-                                app.event_log(LogEvent::ServiceKK2Resend(&session), current_time);
-                                PACKET_TYPE_NOISE_KK_PATTERN_2
-                            };
-                            if let Some((send, _)) = send_to(&session) {
-                                let _ = session.send_control(&state, send, packet_type, noise_message);
-                            }
-                        }
-                        retry_next
-                    }
-                }
-                KeyConfirm { next_retry_time, timeout, .. } => {
-                    if let Some(ts) = process_timer(next_retry_time, App::RETRY_INTERVAL_MS, current_time) {
-                        ts
-                    } else {
-                        if *timeout <= current_time {
-                            app.event_log(LogEvent::ServiceKeyConfirmTimeout(&session), current_time);
-                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
-                            drop(state);
-                            session.expire_inner(&self.0, &mut session_queue);
-                        } else {
-                            app.event_log(LogEvent::ServiceKeyConfirmResend(&session), current_time);
-                            if let Some((send, _)) = send_to(&session) {
-                                let _ = session.send_control(&state, send, PACKET_TYPE_KEY_CONFIRM, &[]);
-                            }
-                        }
-                        retry_next
-                    }
-                }
-                Null => retry_next,
-            };
-            session_queue.change_priority(queue_idx, Reverse(next_timer));
+            });
+            if let Some(next_timer) = result {
+                next_service_time = next_service_time.min(next_timer);
+                session_queue.change_priority(queue_idx, Reverse(next_timer));
+            } else {
+                session.expire_inner(Some(ctx), Some(&mut session_queue));
+            }
         }
         drop(session_queue);
 
@@ -811,9 +646,9 @@ impl<App: ApplicationLayer> Context<App> {
             .unassociated_defrag_cache
             .lock()
             .unwrap()
-            .check_for_expiry(App::INITIAL_OFFER_TIMEOUT_MS, current_time);
+            .check_for_expiry(App::SETTINGS.fragment_assembly_timeout as i64, current_time);
         self.0.unassociated_handshake_states.service(current_time);
 
         next_service_time
-    } */
+    }
 }

From df2c589d09f04213b819b39b8f8fd204720e36e4 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 08:37:16 -0400
Subject: [PATCH 20/50] refactored

---
 src/{applicationlayer.rs => application.rs} |   73 +-
 src/challenge.rs                            |    5 +-
 src/context.rs                              |  436 ---
 src/crypto/mod.rs                           |   16 +-
 src/error.rs                                |  110 -
 src/frag_cache.rs                           |    2 +-
 src/fragged.rs                              |    2 +-
 src/handshake_cache.rs                      |    2 +-
 src/lib.rs                                  |    2 +-
 src/log_event.rs                            |    2 +-
 src/proto.rs                                |    7 +-
 src/proto_old.rs                            |  296 --
 src/ratchet_state.rs                        |  147 +-
 src/ratchet_state_old.rs                    |   62 -
 src/result.rs                               |    2 +-
 src/symmetric_state.rs                      |    6 +-
 src/symmetric_state_old.rs                  |  156 --
 src/zeta.rs                                 |  116 +-
 src/zssp copy.rs                            | 2704 -------------------
 src/zssp.rs                                 |    9 +-
 20 files changed, 240 insertions(+), 3915 deletions(-)
 rename src/{applicationlayer.rs => application.rs} (82%)
 delete mode 100644 src/context.rs
 delete mode 100644 src/error.rs
 delete mode 100644 src/proto_old.rs
 delete mode 100644 src/ratchet_state_old.rs
 delete mode 100644 src/symmetric_state_old.rs
 delete mode 100644 src/zssp copy.rs

diff --git a/src/applicationlayer.rs b/src/application.rs
similarity index 82%
rename from src/applicationlayer.rs
rename to src/application.rs
index f078770..0a28af9 100644
--- a/src/applicationlayer.rs
+++ b/src/application.rs
@@ -1,21 +1,12 @@
 use std::sync::Arc;
+use rand_core::{CryptoRng, RngCore};
 
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-use crate::crypto::aes::{AesDec, AesEnc, HighThroughputAesGcmPool, LowThroughputAesGcm};
-use crate::crypto::kyber1024::Kyber1024PrivateKey;
-use crate::crypto::p384::{P384KeyPair, P384PublicKey};
-use crate::crypto::rand_core::{CryptoRng, RngCore};
-use crate::crypto::sha512::{HashSha512, HmacSha512};
-use crate::proto::RATCHET_SIZE;
+use crate::crypto::*;
 use crate::zeta::Session;
 use crate::ratchet_state::RatchetState;
-//use crate::{log_event::LogEvent, Session};
+
+pub use crate::proto::RATCHET_SIZE;
+pub use crate::ratchet_state::*;
 
 /// A container for a vast majority of the dynamic settings within ZSSP, including all time-based settings.
 /// If the user wishes to measure time in units other than milliseconds for some reason, then they can
@@ -194,22 +185,17 @@ pub trait ApplicationLayer: Sized {
     /// Function to accept sessions after final negotiation.
     /// The second argument is the identity that the remote peer sent us. The application
     /// must verify this identity is associated with the remote peer's static key.
-    /// To prevent desync, if this function returns (Some(_), _), no other open session with the
-    /// same remote peer must exist. Drop or call expire on any pre-existing sessions before returning.
+    /// To prevent desync, if this function specifies that we should connect, no other open session
+    /// with the same remote peer must exist. Drop or call expire on any pre-existing sessions
+    /// before returning.
     fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self>;
 
     /// Lookup a specific ratchet state based on its ratchet fingerprint.
     /// This function will be called whenever Alice attempts to connect to us with a non-empty
     /// ratchet fingerprint.
     ///
-    /// If the ratchet key was found, the function should return `RestoreAction::RestoreRatchet`. This will
-    /// cause us to connect to Alice using the returned ratchet number and ratchet key.
-    ///
-    /// If the ratchet key could not be found, the application may choose between returning
-    /// `RatchetAction::DowngradeRatchet` or `RatchetAction::FailAuthentication`.
-    /// If `RatchetAction::DowngradeRatchet` is returned we will attempt to convince Alice to downgrade
-    /// to the empty ratchet key, restarting the ratchet chain.
-    /// If `RatchetAction::FailAuthentication` is returned Alice's connection will be silently dropped.
+    /// If a ratchet state with a matching fingerprint could not be found, this function should
+    /// return `Ok(None)`.
     fn restore_by_fingerprint(
         &self,
         ratchet_fingerprint: &[u8; RATCHET_SIZE],
@@ -232,17 +218,10 @@ pub trait ApplicationLayer: Sized {
         &self,
         remote_static_key: &Self::PublicKey,
         session_data: &Self::SessionData,
-    ) -> Result<(RatchetState, Option<RatchetState>), Self::StorageError>;
-    /// Atomically save `current_state1` and `current_state2` so that them and only them can be
-    /// restored with `restore_by_identity` and `restore_by_fingerprint` through a system restart.
-    /// Theses should overwrite the previous ratchet states 1 and 2 saved to storage.
-    ///
-    /// `state_added` will be equal to the brand new ratchet state that was added in this update,
-    /// or `None` if there is not a new ratchet state this update. `state_deleted1` and
-    /// `state_deleted2` will be equal to any ratchet states that are to be deleted and overwritten
-    /// as a result of this update, or `None` if there is not one to be deleted.
-    /// `state_added` will always have a non-empty (`Some()`) ratchet fingerprint, and it will
-    /// always be equal to `current_state1`.
+    ) -> Result<Option<RatchetStates>, Self::StorageError>;
+    /// Atomically commit the update specified by `update_data` to storage, or return an error if
+    /// the update could not be made.
+    /// The implementor is free to choose how to apply these updates to storage.
     ///
     /// If this returns `Err(IoError)`, the packet which triggered this function to be called will be
     /// dropped, and no session state will be mutated, preserving synchronization. The remote peer
@@ -254,8 +233,7 @@ pub trait ApplicationLayer: Sized {
     /// fix is to reset both ratchet keys to empty.
     ///
     /// This function may also save state to volatile storage, in which case all peers which connect
-    /// to us will have to allow downgrade, i.e. `initiator_disallows_downgrade` returns false
-    /// and/or `check_accept_session` returns `(Some(true, _), _)`.
+    /// to us will have to allow downgrade across the board.
     /// Otherwise, when we restart, we will not be allowed to reconnect.
     fn save_ratchet_state(
         &self,
@@ -271,16 +249,21 @@ pub trait ApplicationLayer: Sized {
     fn event_log(&self, event: LogEvent<'_, Self>);
 }
 
-pub struct RatchetUpdate<'a> {
-    pub state1: &'a RatchetState,
-    pub state2: Option<&'a RatchetState>,
-    pub state1_was_just_added: bool,
-    pub state_deleted1: Option<&'a RatchetState>,
-    pub state_deleted2: Option<&'a RatchetState>,
-}
-
+/// A collection of fields specifying how to complete the key exchange with a specific remote peer,
+/// used by Bob, the responder, at the very last stage of the key exchange.
+///
+/// Corresponds to the *Accept* callback of Transition Algorithm 4.
 pub struct AcceptAction<App: ApplicationLayer> {
+    /// The data object to be attached to the session if we successfully connect.
+    /// If this field is None then we will not connect to this remote peer.
     pub session_data: Option<App::SessionData>,
+    /// Whether or not we will accept a connection with the remote peer when they do not have a
+    /// ratchet key that we think they should have.
     pub responder_disallows_downgrade: bool,
+    /// Whether or not to send an explicit rejection packet to the remote peer if we do not create
+    /// a session with them.
+    ///
+    /// This field will not be used if `session_data` is `Some` and the remote peer passes all other
+    /// authentication checks.
     pub responder_silently_rejects: bool,
 }
diff --git a/src/challenge.rs b/src/challenge.rs
index 11e4578..c63c916 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -4,10 +4,7 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use rand_core::{CryptoRng, RngCore};
 
 use crate::antireplay::Window;
-use crate::crypto::{
-    secure_eq,
-    sha512::{HashSha512, SHA512_HASH_SIZE},
-};
+use crate::crypto::*;
 use crate::proto::*;
 
 pub struct ChallengeContext {
diff --git a/src/context.rs b/src/context.rs
deleted file mode 100644
index 2320365..0000000
--- a/src/context.rs
+++ /dev/null
@@ -1,436 +0,0 @@
-use rand_core::RngCore;
-use std::cmp::Reverse;
-use std::collections::hash_map::Entry;
-use std::collections::HashMap;
-use std::hash::Hash;
-use std::num::NonZeroU32;
-use std::sync::{Arc, Mutex, Weak, RwLock};
-
-use crate::applicationlayer::ApplicationLayer;
-use crate::crypto::aes::{AES_256_KEY_SIZE, AES_GCM_IV_SIZE};
-use crate::frag_cache::UnassociatedFragCache;
-use crate::handshake_cache::UnassociatedHandshakeCache;
-use crate::indexed_heap::IndexedBinaryHeap;
-//use crate::fragmentation::{send_with_fragmentation, DefragBuffer};
-use crate::proto::*;
-use crate::result::{byzantine_fault, ReceiveError, ReceiveOk, SendError, SessionEvent};
-use crate::zeta::*;
-#[cfg(feature = "logging")]
-use crate::LogEvent::*;
-use crate::{challenge::ChallengeContext, result::OpenError};
-
-/// Macro to turn off logging at compile time.
-macro_rules! log {
-    ($app:expr, $event:expr) => {
-        #[cfg(feature = "logging")]
-        $app.event_log($event);
-    };
-}
-pub(crate) use log;
-
-/// Session context for local application.
-///
-/// Each application using ZSSP must create an instance of this to own sessions and
-/// defragment incoming packets that are not yet associated with a session.
-///
-/// Internally this is just a clonable Arc, so it can be safely shared with multiple threads.
-pub struct Context<App: ApplicationLayer>(Arc<ContextInner<App>>);
-impl<App: ApplicationLayer> Clone for Context<App> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-pub(crate) type SessionMap<App> = RwLock<HashMap<NonZeroU32, Weak<Session<App>>>>;
-
-pub(crate) struct ContextInner<App: ApplicationLayer> {
-    pub(crate) rng: Mutex<App::Rng>,
-    pub(crate) s_secret: App::KeyPair,
-    pub(crate) session_queue: Mutex<IndexedBinaryHeap<Weak<Session<App>>, Reverse<i64>>>,
-    pub(crate) session_map: SessionMap<App>,
-    unassociated_defrag_cache: Mutex<UnassociatedFragCache<App::IncomingPacketBuffer>>,
-    unassociated_handshake_states: UnassociatedHandshakeCache<App>,
-    //pub(crate) b2_map: Mutex<HashMap<NonZeroU32, StateB2<App>>>,
-
-    //hello_defrag: Mutex<DefragBuffer>,
-    challenge: ChallengeContext,
-}
-
-/// Corresponds to Figure 10 found in Section 4.3.
-fn to_aes_nonce(pn: &[u8; PACKET_NONCE_SIZE]) -> [u8; AES_GCM_IV_SIZE] {
-    let mut an = [0u8; AES_GCM_IV_SIZE];
-    an[2..].copy_from_slice(pn);
-    an
-}
-/// Corresponds to Figure 14 found near Section 6.
-fn to_packet_nonce(n: &[u8; AES_GCM_IV_SIZE]) -> &[u8; PACKET_NONCE_SIZE] {
-    (&n[n.len() - PACKET_NONCE_SIZE..]).try_into().unwrap()
-}
-
-impl<App: ApplicationLayer> Context<App> {
-    /// Create a new session context.
-    pub fn new(static_secret_key: App::KeyPair, mut rng: App::Rng) -> Self {
-        let challenge = ChallengeContext::new(&mut rng);
-        Self(Arc::new(ContextInner {
-            rng: Mutex::new(rng),
-            s_secret: static_secret_key,
-            session_map: RwLock::new(HashMap::new()),
-            challenge,
-            session_queue: Mutex::new(IndexedBinaryHeap::new()),
-            unassociated_defrag_cache: Mutex::new(UnassociatedFragCache::new()),
-            unassociated_handshake_states: UnassociatedHandshakeCache::new(),
-        }))
-    }
-    /// Create a new session and send initial packet(s) to other side.
-    ///
-    /// This will return SendError::DataTooLarge if the combined size of the metadata and the local
-    /// static public blob (as retrieved from the application layer) exceed MAX_INIT_PAYLOAD_SIZE.
-    ///
-    /// * `app` - Application layer instance
-    /// * `send` - Function to be called to send one or more initial packets to the remote being
-    ///   contacted
-    /// * `mtu` - MTU for initial packets
-    /// * `static_remote_key` - Remote side's static public NIST P-384 key
-    /// * `session_data` - Arbitrary data meaningful to the application to include with session
-    ///   object
-    /// * `identity` - Payload to be sent to Bob that contains the information necessary
-    ///   for the upper protocol to authenticate and approve of Alice's identity
-    pub fn open(
-        &self,
-        app: App,
-        send: impl FnMut(Vec<u8>) -> bool,
-        mut mtu: usize,
-        static_remote_key: App::PublicKey,
-        session_data: App::SessionData,
-        identity: Vec<u8>,
-    ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
-        mtu = mtu.max(MIN_TRANSPORT_MTU);
-        let ctx = &self.0;
-
-        // Process zeta layer.
-        trans_to_a1(
-            app,
-            &ctx,
-            static_remote_key,
-            session_data,
-            identity,
-            |Packet(kid, nonce, payload): &Packet| {
-                // Process fragmentation layer.
-                send_with_fragmentation::<App>(send, mtu, *kid, to_packet_nonce(&nonce), payload, None);
-            },
-        )
-    }
-
-    /// Receive, authenticate, decrypt, and process a physical wire packet.
-    ///
-    /// * `app` - Interface to application using ZSSP
-    /// * `send_unassociated_reply` - Function to send reply packets directly when no session exists
-    /// * `send_unassociated_mtu` - MTU for unassociated replies
-    /// * `send_to` - Function to get senders for existing sessions, permitting MTU and path lookup
-    /// * `remote_address` - Whatever the remote address is, as long as you can Hash it
-    /// * `raw_fragment` - Buffer containing incoming wire packet
-    pub fn receive<'a, SendFn: FnMut(Vec<u8>) -> bool>(
-        &self,
-        app: App,
-        send_unassociated_reply: impl FnMut(Vec<u8>) -> bool,
-        mut send_unassociated_mtu: usize,
-        send_to: impl FnOnce(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
-        remote_address: &impl Hash,
-        raw_fragment: Vec<u8>,
-    ) -> Result<ReceiveOk<App>, ReceiveError<App::StorageError>> {
-        use crate::result::FaultType::*;
-        send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
-        let ctx = &self.0;
-
-        // Multiplex session.
-        let kid_recv = u32::from_be_bytes(raw_fragment[..KID_SIZE].try_into().unwrap());
-        if let Some(kid_recv) = NonZeroU32::new(kid_recv) {
-            let session = ctx.session_map.lock().unwrap().get(&kid_recv).map(|r| r.upgrade());
-            if let Some(Some(session)) = session {
-                // Process recv fragmentation layer.
-                let mut zeta = session.0.lock().unwrap();
-                let result = zeta.defrag.received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
-                    let (p, c) = from_nonce(n);
-                    if p != PACKET_TYPE_DATA {
-                        log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
-                    }
-                    if p == PACKET_TYPE_HANDSHAKE_RESPONSE {
-                        if !matches!(&zeta.beta, ZetaAutomata::A1(_)) {
-                            // A resent handshake response from Bob may have arrived out of order,
-                            // after we already received one.
-                            return Err(byzantine_fault!(OutOfSequence, false));
-                        }
-                        if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
-                            return Err(byzantine_fault!(ExpiredCounter, true));
-                        }
-                        Ok(())
-                    } else if PACKET_TYPE_USES_COUNTER_RANGE.contains(&p) {
-                        if !zeta.check_counter_window(c) {
-                            // The counter window has finite memory and so will occasionally give
-                            // false positives on very out-of-order packets.
-                            return Err(byzantine_fault!(ExpiredCounter, false));
-                        }
-                        Ok(())
-                    } else if p == PACKET_TYPE_HANDSHAKE_COMPLETION {
-                        // The handshake completion packet could have been resent.
-                        return Err(byzantine_fault!(InvalidPacket, false));
-                    } else {
-                        return Err(byzantine_fault!(InvalidPacket, true));
-                    }
-                })?;
-                if let Some((pn, mut assembled_packet)) = result {
-                    // Process recv zeta layer.
-                    let send_associated = |Packet(kid, nonce, payload): &Packet, hk: Option<&[u8; AES_256_KEY_SIZE]>| {
-                        if let Some((send_fragment, mut mtu)) = send_to(&session) {
-                            mtu = mtu.max(MIN_TRANSPORT_MTU);
-                            send_with_fragmentation::<App>(send_fragment, mtu, *kid, to_packet_nonce(&nonce), payload, hk);
-                        }
-                    };
-
-                    let (p, _) = from_nonce(&pn);
-                    let ret = match p {
-                        PACKET_TYPE_DATA => {
-                            received_payload_in_place(&mut zeta, kid_recv, to_aes_nonce(&pn), &mut assembled_packet)?;
-                            SessionEvent::Data(assembled_packet)
-                        }
-                        PACKET_TYPE_HANDSHAKE_RESPONSE => {
-                            log!(app, ReceivedRawX2);
-                            received_x2_trans(
-                                &mut zeta,
-                                &session,
-                                &app,
-                                &ctx,
-                                kid_recv,
-                                to_aes_nonce(&pn),
-                                assembled_packet,
-                                send_associated,
-                            )?;
-                            log!(app, X2IsAuthSentX3(&session));
-                            SessionEvent::Control
-                        }
-                        PACKET_TYPE_KEY_CONFIRM => {
-                            log!(app, ReceivedRawKeyConfirm);
-                            let result =
-                                received_c1_trans(&mut zeta, &app, &ctx.rng, kid_recv, to_aes_nonce(&pn), assembled_packet, send_associated)?;
-                            log!(app, KeyConfirmIsAuthSentAck(&session));
-                            if result {
-                                SessionEvent::Established
-                            } else {
-                                SessionEvent::Control
-                            }
-                        }
-                        PACKET_TYPE_ACK => {
-                            log!(app, ReceivedRawAck);
-                            received_c2_trans(&mut zeta, &app, &ctx.rng, kid_recv, to_aes_nonce(&pn), assembled_packet)?;
-                            log!(app, AckIsAuth(&session));
-                            SessionEvent::Control
-                        }
-                        PACKET_TYPE_REKEY_INIT => {
-                            log!(app, ReceivedRawK1);
-                            received_k1_trans(
-                                &mut zeta,
-                                &session,
-                                &app,
-                                &ctx.rng,
-                                &ctx.session_map,
-                                &ctx.s_secret,
-                                kid_recv,
-                                to_aes_nonce(&pn),
-                                assembled_packet,
-                                send_associated,
-                            )?;
-                            log!(app, K1IsAuthSentK2(&session));
-                            SessionEvent::Control
-                        }
-                        PACKET_TYPE_REKEY_COMPLETE => {
-                            log!(app, ReceivedRawK2);
-                            received_k2_trans(&mut zeta, &app, kid_recv, to_aes_nonce(&pn), assembled_packet, send_associated)?;
-                            log!(app, K2IsAuthSentKeyConfirm(&session));
-                            SessionEvent::Control
-                        }
-                        PACKET_TYPE_SESSION_REJECTED => {
-                            log!(app, ReceivedRawD);
-                            received_d_trans(&mut zeta, kid_recv, to_aes_nonce(&pn), assembled_packet)?;
-                            log!(app, DIsAuthClosedSession(&session));
-                            SessionEvent::Rejected
-                        }
-                        _ => return Err(byzantine_fault!(InvalidPacket, true)), // This is unreachable.
-                    };
-                    drop(zeta);
-                    Ok(ReceiveOk::Session(session, ret))
-                } else {
-                    Ok(ReceiveOk::Unassociated)
-                }
-            } else {
-                let mut b2_map = ctx.b2_map.lock().unwrap();
-                if let Entry::Occupied(mut entry) = b2_map.entry(kid_recv) {
-                    let zeta = entry.get_mut();
-                    // Process recv fragmentation layer.
-                    let result = zeta.defrag.received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
-                        let (p, c) = from_nonce(n);
-                        log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
-                        if p == PACKET_TYPE_HANDSHAKE_COMPLETION && c == 0 {
-                            Ok(())
-                        } else {
-                            Err(byzantine_fault!(InvalidPacket, true))
-                        }
-                    })?;
-                    if let Some((_, assembled_packet)) = result {
-                        log!(app, ReceivedRawX3);
-                        let zeta = entry.remove();
-                        let session = received_x3_trans(zeta, &app, ctx, kid_recv, assembled_packet, |Packet(kid, nonce, payload), hk| {
-                            send_with_fragmentation::<App>(
-                                send_unassociated_reply,
-                                send_unassociated_mtu,
-                                *kid,
-                                to_packet_nonce(&nonce),
-                                payload,
-                                hk,
-                            );
-                        })?;
-                        log!(app, X3IsAuthSentKeyConfirm(&session));
-                        Ok(ReceiveOk::Session(session, SessionEvent::NewSession))
-                    } else {
-                        Ok(ReceiveOk::Unassociated)
-                    }
-                } else {
-                    // When sessions are added or dropped or packets arrive extremely delayed it is
-                    // possible to receive no longer recognized key ids.
-                    Err(byzantine_fault!(UnknownLocalKeyId, false))
-                }
-            }
-        } else {
-            // Process recv fragmentation layer.
-            let result = ctx
-                .hello_defrag
-                .lock()
-                .unwrap()
-                .received_fragment::<App>(raw_fragment, app.time(), |n, frag_no, frag_count| {
-                    let (p, c) = from_nonce(n);
-                    log!(app, ReceivedRawFragment(p, c, frag_no, frag_count));
-                    if p == PACKET_TYPE_HANDSHAKE_HELLO || p == PACKET_TYPE_CHALLENGE {
-                        Ok(())
-                    } else {
-                        Err(byzantine_fault!(InvalidPacket, true))
-                    }
-                })?;
-            if let Some((n, mut assembled_packet)) = result {
-                let (p, _) = from_nonce(&n);
-                if p == PACKET_TYPE_HANDSHAKE_HELLO {
-                    log!(app, ReceivedRawX1);
-                    // Process recv challenge layer.
-                    let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
-                    let result = ctx
-                        .challenge
-                        .lock()
-                        .unwrap()
-                        .process_hello::<App::Hash>(remote_address, (&assembled_packet[challenge_start..]).try_into().unwrap());
-                    if let Err(challenge) = result {
-                        log!(app, X1FailedChallengeSentNewChallenge);
-                        let mut challenge_packet = Vec::new();
-                        challenge_packet.extend(&assembled_packet[..KID_SIZE]);
-                        challenge_packet.extend(&challenge);
-                        let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
-                        send_with_fragmentation::<App>(
-                            send_unassociated_reply,
-                            send_unassociated_mtu,
-                            0,
-                            to_packet_nonce(&nonce),
-                            &challenge_packet,
-                            None,
-                        );
-                        // If we issue a challenge the first hello packet will always fail.
-                        return Err(byzantine_fault!(FailedAuth, false));
-                    } else if let Ok(true) = result {
-                        log!(app, X1SucceededChallenge);
-                    }
-                    assembled_packet.truncate(challenge_start);
-
-                    // Process recv zeta layer.
-                    received_x1_trans(&app, &ctx, to_aes_nonce(&n), assembled_packet, |Packet(kid, nonce, payload), hk| {
-                        send_with_fragmentation::<App>(
-                            send_unassociated_reply,
-                            send_unassociated_mtu,
-                            *kid,
-                            to_packet_nonce(&nonce),
-                            payload,
-                            Some(hk),
-                        );
-                    })?;
-                    log!(app, X1IsAuthSentX2);
-                    Ok(ReceiveOk::Unassociated)
-                } else if p == PACKET_TYPE_CHALLENGE {
-                    log!(app, ReceivedRawChallenge);
-                    // Process recv challenge layer.
-                    if assembled_packet.len() != KID_SIZE + CHALLENGE_SIZE {
-                        return Err(byzantine_fault!(InvalidPacket, true));
-                    }
-                    if let Some(kid_recv) = NonZeroU32::new(u32::from_be_bytes(assembled_packet[..KID_SIZE].try_into().unwrap())) {
-                        if let Some(Some(session)) = ctx.session_map.lock().unwrap().get(&kid_recv).map(|r| r.upgrade()) {
-                            let mut zeta = session.0.lock().unwrap();
-                            respond_to_challenge(&mut zeta, &ctx.rng, &assembled_packet[KID_SIZE..].try_into().unwrap());
-                            log!(app, ChallengeIsAuth(&session));
-                            return Ok(ReceiveOk::Unassociated);
-                        }
-                    }
-                    Err(byzantine_fault!(UnknownLocalKeyId, true))
-                } else {
-                    Err(byzantine_fault!(InvalidPacket, true))
-                }
-            } else {
-                Ok(ReceiveOk::Unassociated)
-            }
-        }
-    }
-
-    /// Send data over the session.
-    ///
-    /// * `session` - The session to send to
-    /// * `send` - Function to call to send physical packet(s); the buffer passed to `send` is a
-    ///   slice of `data`
-    /// * `mtu` - The MTU of the link, all packets passed to `send` will be at most `mtu` in length
-    /// * `payload` - Data to send
-    pub fn send(&self, session: &Arc<Session<App>>, send: impl FnMut(Vec<u8>) -> bool, mut mtu: usize, payload: Vec<u8>) -> Result<(), SendError> {
-        mtu = mtu.max(MIN_TRANSPORT_MTU);
-        let mut zeta = session.0.lock().unwrap();
-        send_payload(&mut zeta, payload, |Packet(kid, nonce, payload), hk| {
-            send_with_fragmentation::<App>(send, mtu, *kid, to_packet_nonce(nonce), &payload, hk);
-        })
-    }
-
-    /// Perform periodic background service and cleanup tasks.
-    ///
-    /// This returns the number of milliseconds until it should be called again. The caller should
-    /// try to satisfy this but small variations in timing of up to a few seconds are not
-    /// a problem.
-    ///
-    /// * `send_to` - Function to get a sender and an MTU to send something over an active session
-    pub fn service<SendFn: FnMut(Vec<u8>) -> bool>(&self, app: App, mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>) -> i64 {
-        let ctx = &self.0;
-        let sessions = ctx.sessions.lock().unwrap();
-        let current_time = app.time();
-        let mut next_timer = i64::MAX;
-        for (_, session) in sessions.iter() {
-            if let Some(session) = session.upgrade() {
-                let mut zeta = session.0.lock().unwrap();
-                service(
-                    &mut zeta,
-                    &session,
-                    ctx,
-                    &app,
-                    current_time,
-                    |Packet(kid, nonce, payload): &Packet, hk| {
-                        if let Some((send_fragment, mut mtu)) = send_to(&session) {
-                            mtu = mtu.max(MIN_TRANSPORT_MTU);
-                            send_with_fragmentation::<App>(send_fragment, mtu, *kid, to_packet_nonce(&nonce), payload, hk);
-                        }
-                    },
-                );
-                next_timer = next_timer.min(zeta.next_timer());
-                zeta.defrag.service::<App>(current_time);
-            }
-        }
-        ctx.hello_defrag.lock().unwrap().service::<App>(current_time);
-        (App::SETTINGS.resend_time as i64).min(next_timer - current_time)
-    }
-}
diff --git a/src/crypto/mod.rs b/src/crypto/mod.rs
index f31b7f6..00ca2aa 100644
--- a/src/crypto/mod.rs
+++ b/src/crypto/mod.rs
@@ -1,13 +1,17 @@
-// (c) 2020-2022 ZeroTier, Inc. -- currently proprietary pending actual release and licensing. See LICENSE.md.
+mod aes;
+pub use self::aes::*;
 
-pub mod aes;
-pub mod kyber1024;
-pub mod p384;
-pub mod sha512;
+mod p384;
+pub use self::p384::*;
+
+mod sha512;
+pub use sha512::*;
+
+mod kyber1024;
+pub use kyber1024::*;
 
 // We re-export our dependencies so it is less of a headache for the implementor to use the same
 // exact version of them.
-pub use pqc_kyber;
 pub use rand_core;
 
 /// Constant time byte slice equality.
diff --git a/src/error.rs b/src/error.rs
deleted file mode 100644
index 63c31c0..0000000
--- a/src/error.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum OpenError<IoError> {
-    /// An invalid parameter was supplied to the function.
-    InvalidPublicKey,
-
-    /// Local identity blob is too large to send, even with fragmentation.
-    DataTooLarge,
-
-    RatchetIoError(IoError),
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum SendError {
-    /// An invalid parameter was supplied to the function.
-    InvalidParameter,
-
-    /// The session has been marked as expired and refuses to send data.
-    /// Several components of ZSSP can cause this to occur, but the most likely situation to be seen
-    /// in practice is where rekeying repeatedly fails due to exceedingly bad network conditions.
-    ///
-    /// The associated session will no longer send or receive data and must be immediately dropped.
-    SessionExpired,
-
-    /// Attempt to send using a session without a shared symmetric key.
-    /// The caller should wait until the handshake has completed.
-    SessionNotEstablished,
-
-    /// Data object is too large to send, even with fragmentation.
-    DataTooLarge,
-}
-
-/// A type of fault occurred because we received a bad packet.
-///
-/// An unauthenticated attacker can intentionally trigger any of these, so it is best to
-/// treat these as raw user input that needs to be sanitize.
-#[derive(Debug, PartialEq, Eq)]
-pub enum FaultType {
-    /// The received packet was addressed to an unrecognized local session.
-    UnknownLocalKeyId,
-
-    /// The received packet from the remote peer was not well formed.
-    InvalidPacket,
-
-    /// Packet failed one or more authentication (MAC) checks.
-    FailedAuthentication,
-
-    /// Packet counter was repeated or outside window of allowed counter values.
-    ExpiredCounter,
-
-    /// Packet contained protocol control parameters that are disallowed at this point in
-    /// time by ZSSP.
-    OutOfSequence,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum ReceiveError<IoError> {
-    /// A type of fault that can occur because a remote peer sent us a bad packet.
-    /// Such packets will be ignored by ZSSP but a user of ZSSP might want to log
-    /// them for debugging or tracing.
-    ///
-    /// Because an unauthenticated remote peer can force these to occur with specific
-    /// contained information, it is recommended in production to either drop these
-    /// immediately, or log them safely to a local output stream and then drop them.
-    ByzantineFault {
-        /// The type of fault that has occurred. Be cautious if you choose to read this
-        /// value, as an attacker has control over it.
-        error: FaultType,
-        /// Some byzantine faults within ZSSP are naturally occurring, i.e. they can occur
-        /// between two well behaved and trusted parties executing the protocol.
-        /// This boolean is true if this is one of these faults. If you go to the file and
-        /// line number specified by this error you will find a comment describing
-        /// how and why exactly this fault can occur naturally.
-        ///
-        /// Faults that can occur because the underlying communication medium is lossy and
-        /// sequentially inconsistent (as in UDP) are considered naturally occurring.
-        /// However ZSSP considers faults that occur because data integrity has not been
-        /// persevered (i.e. bits have been flipped) to be unnatural.
-        /// ZSSP also considers collisions of what are supposed to be uniform random
-        /// numbers to be unnatural.
-        is_naturally_occurring: bool,
-        /// The file of this implementation of ZSSP from which this error was generated.
-        file: &'static str,
-        /// The line number of this implementation of ZSSP from which this error was
-        /// generated. As such this number uniquely identifies each possible fault that
-        /// can occur during ZSSP. Advanced user can use this information to debug more
-        /// complicated usages of ZSSP.
-        line: u32,
-    },
-
-    /// The caller supplied data buffer is too small to receive data from the remote peer.
-    /// An attacker can cause this to occur, so users should place a hard upper limit on
-    /// how large their supplied data buffers can be.
-    DataBufferTooSmall,
-
-    /// Rekeying failed and session secret has reached its hard usage count limit.
-    /// The associated session will no longer function and has to be dropped.
-    MaxKeyLifetimeExceeded,
-
-    /// One of the ratchet saving or lookup functions returned an error, so the packet had to be
-    /// dropped.
-    RatchetIoError(IoError),
-}
diff --git a/src/frag_cache.rs b/src/frag_cache.rs
index e132f4c..cbe95df 100644
--- a/src/frag_cache.rs
+++ b/src/frag_cache.rs
@@ -10,7 +10,7 @@ use std::collections::hash_map::RandomState;
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::mem::MaybeUninit;
 
-use crate::crypto::aes::AES_GCM_IV_SIZE;
+use crate::crypto::AES_GCM_IV_SIZE;
 use crate::fragged::Assembled;
 use crate::proto::{MAX_FRAGMENTS, MAX_UNASSOCIATED_FRAGMENTS, MAX_UNASSOCIATED_PACKETS, MAX_UNASSOCIATED_PACKET_SIZE};
 
diff --git a/src/fragged.rs b/src/fragged.rs
index 5cb1a49..38a0e18 100644
--- a/src/fragged.rs
+++ b/src/fragged.rs
@@ -9,7 +9,7 @@
 use arrayvec::ArrayVec;
 use std::mem::{needs_drop, zeroed, MaybeUninit};
 
-use crate::crypto::aes::AES_GCM_IV_SIZE;
+use crate::crypto::AES_GCM_IV_SIZE;
 use crate::proto::{MAX_FRAGMENTS, NONCE_SIZE_DIFF};
 
 pub type Assembled<Fragment> = ArrayVec<Fragment, MAX_FRAGMENTS>;
diff --git a/src/handshake_cache.rs b/src/handshake_cache.rs
index 1344412..f5cd728 100644
--- a/src/handshake_cache.rs
+++ b/src/handshake_cache.rs
@@ -11,7 +11,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock};
 
 use crate::zeta::StateB2;
-use crate::{proto::MAX_UNASSOCIATED_HANDSHAKE_STATES, applicationlayer::ApplicationLayer};
+use crate::{proto::MAX_UNASSOCIATED_HANDSHAKE_STATES, application::ApplicationLayer};
 
 pub(crate) struct UnassociatedHandshakeCache<Application: ApplicationLayer> {
     has_pending: AtomicBool, // Allowed to be falsely positive
diff --git a/src/lib.rs b/src/lib.rs
index 358dc61..bd202c4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -8,7 +8,7 @@
 pub mod crypto;
 
 mod antireplay;
-pub mod applicationlayer;
+pub mod application;
 mod challenge;
 mod frag_cache;
 mod fragged;
diff --git a/src/log_event.rs b/src/log_event.rs
index 43fdc32..a160ad9 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -7,7 +7,7 @@
  */
 use std::sync::Arc;
 
-use crate::{zeta::Session, applicationlayer::ApplicationLayer};
+use crate::{zeta::Session, application::ApplicationLayer};
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
 pub enum LogEvent<'a, Application: ApplicationLayer> {
diff --git a/src/proto.rs b/src/proto.rs
index 91ea301..8c1d252 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -1,9 +1,4 @@
-use crate::crypto::{
-    aes::{AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE},
-    kyber1024::{KYBER_CIPHERTEXT_SIZE, KYBER_PUBLIC_KEY_SIZE},
-    p384::P384_PUBLIC_KEY_SIZE,
-    sha512::SHA512_HASH_SIZE,
-};
+use crate::crypto::*;
 
 /* Common constants */
 
diff --git a/src/proto_old.rs b/src/proto_old.rs
deleted file mode 100644
index 2f83f3e..0000000
--- a/src/proto_old.rs
+++ /dev/null
@@ -1,296 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-
-use std::hash::Hasher;
-use std::mem::size_of;
-
-use crate::crypto::aes::AES_GCM_TAG_SIZE;
-use crate::crypto::p384::P384_PUBLIC_KEY_SIZE;
-use crate::crypto::pqc_kyber::{KYBER_CIPHERTEXTBYTES, KYBER_PUBLICKEYBYTES};
-use crate::crypto::sha512::{HashSha512, SHA512_HASH_SIZE};
-use hex_literal::hex;
-
-/// Minimum size of a valid physical ZSSP packet of any type. Anything smaller is discarded.
-pub const MIN_PACKET_SIZE: usize = HEADER_SIZE + AES_GCM_TAG_SIZE;
-
-/// Minimum physical MTU for ZSSP to function.
-pub const MIN_TRANSPORT_MTU: usize = 128;
-
-pub const RATCHET_SIZE: usize = 32;
-
-/// The application has the ability to attach a data payload to Alice's handshake.
-/// It will be the first payload Bob receives from Alice.
-/// The application also must attach a static public identity to their handshake.
-/// The combined size of both in bytes must be at most this value.
-///
-/// If not ZSSP will return `OpenError::DataTooLarge` and refuse to create a session object.
-pub const MAX_IDENTITY_BLOB_SIZE: usize = NoiseXKPattern3::MAX_SIZE - NoiseXKPattern3::MIN_SIZE;
-
-/// Initial value of 'h'.
-/// echo -n 'Noise_XKhfs+psk2_P384+Kyber1024_AESGCM_SHA512' | shasum -a 512
-pub(crate) const INITIAL_H: [u8; SHA512_HASH_SIZE] =
-    hex!("cd1f422196a5a614e24392cf34dcbf340ee61ad6ee6834274ff35fd42a7a5c44d04a045101555548a291778dd036b93ae21005a26c003213f57a5df9fb17f745");
-/// Initial value of 'ck' for rekeying.
-/// echo -n 'Noise_KKpsk0_P384_AESGCM_SHA512' | shasum -a 512
-pub(crate) const INITIAL_H_REKEY: [u8; SHA512_HASH_SIZE] =
-    hex!("daeedd651ac9c5173f2eaaff996beebac6f3f1bfe9a70bb1cc54fa1fb2bf46260d71a3c4fb4d4ee36f654c31773a8a15e5d5be974a0668dc7db70f4e13ed172e");
-
-pub(crate) const SESSION_ID_SIZE: usize = 4;
-
-pub(crate) const PACKET_TYPE_NOISE_XK_PATTERN_1: u8 = 0;
-pub(crate) const PACKET_TYPE_NOISE_XK_PATTERN_2: u8 = 1;
-pub(crate) const PACKET_TYPE_NOISE_XK_PATTERN_3: u8 = 2;
-pub(crate) const PACKET_TYPE_KEY_CONFIRM: u8 = 3;
-pub(crate) const PACKET_TYPE_ACK: u8 = 4;
-pub(crate) const PACKET_TYPE_NOISE_KK_PATTERN_1: u8 = 5;
-pub(crate) const PACKET_TYPE_NOISE_KK_PATTERN_2: u8 = 6;
-pub(crate) const PACKET_TYPE_SESSION_REJECTED: u8 = 7;
-pub(crate) const PACKET_TYPE_DATA: u8 = 8;
-pub(crate) const PACKET_TYPE_BOB_DOS_CHALLENGE: u8 = 9;
-pub(crate) const PACKET_TYPE_RANGE_TRANSPORT: std::ops::Range<u8> = 3..9;
-
-/// Noise asks that the counter be initialized to 0 but for out of order reasons we have
-/// to start it at 1.
-/// Since with unreliable transport the first counter could always end up dropped this is
-/// functionally equivalent to initializing to 0.
-pub(crate) const INIT_COUNTER: u64 = 0;
-pub(crate) const LABEL_RATCHET_STATE: u8 = b'R';
-pub(crate) const LABEL_HEADER_KEY: u8 = b'H';
-pub(crate) const LABEL_KEX_KEY: u8 = b'K';
-
-/// Size of keys used during derivation, mixing, etc.
-pub(crate) const HASHLEN: usize = SHA512_HASH_SIZE;
-
-pub(crate) const HEADER_SIZE: usize = 16;
-pub(crate) const HEADER_PROTECT_ENC_START: usize = 4;
-pub(crate) const HEADER_PROTECT_ENC_END: usize = 20;
-pub(crate) const CHALLENGE_COUNTER_SIZE: usize = 8;
-pub(crate) const CHALLENGE_MAC_SIZE: usize = 16;
-pub(crate) const CHALLENGE_POW_SIZE: usize = 8;
-pub(crate) const CHALLENGE_SALT_SIZE: usize = 32;
-
-pub(crate) const MAX_NOISE_HANDSHAKE_SIZE: usize = MAX_FRAGMENTS * MIN_TRANSPORT_MTU;
-pub(crate) const CONTROL_PACKET_MAX_SIZE: usize = HEADER_SIZE + NoiseKKPattern1or2::SIZE + AES_GCM_TAG_SIZE;
-pub(crate) const CONTROL_PACKET_MIN_SIZE: usize = HEADER_SIZE + AES_GCM_TAG_SIZE;
-
-/// Determines the number of counters a session will remember. If a counter arrives over
-/// this amount out of order relative to other received counters, it is likely to be
-/// rejected on the basis that the session can't remember if this counter was replayed.
-/// Increasing this value makes a session consume more memory.
-pub(crate) const COUNTER_WINDOW_MAX_OOO: usize = 64;
-/// Maximum number of counter steps that the counter is allowed to skip ahead.
-/// This cannot be changed away from 2^24 without changing the header nonce handling code.
-pub(crate) const COUNTER_WINDOW_MAX_SKIP_AHEAD: u64 = 16777216;
-/// Similar to `COUNTER_WINDOW_MAX_OOO`, except this governs the receive context challenge
-/// counter rather than the session counter.
-/// When Bob issues a challenge to Alice to mitigate DDOS, Bob will only accept Alice's
-/// response once, and then its attached counter is added to the window.
-pub(crate) const CHALLENGE_COUNTER_WINDOW_MAX_OOO: usize = 32;
-/// We hard-expire the Noise counter long before we reach u64::MAX because of the ABA problem.
-/// Over (1<<16) threads would have to attempt to increment the counter at the same time
-/// to overflow it.
-/// Having (1<<16) threads active at the same time would crash basically any system.
-pub(crate) const THREAD_SAFE_COUNTER_HARD_EXPIRE: u64 = u64::MAX - (1 << 16);
-
-/// Maximum number of fragments a single packet may be split into. If a packet cannot fit
-/// into this number of fragments it will be dropped.
-pub(crate) const MAX_FRAGMENTS: usize = 48; // hard protocol max: 63
-/// Maximum window over which session packets may be reordered to be defragmented and
-/// reassembled. Out of order fragments may be dropped in favor of newer fragments.
-/// Increasing this value makes a session consume more significantly more memory.
-pub(crate) const SESSION_MAX_FRAGMENTS_OOO: usize = 32;
-
-/// The maximum number of unassociated packets that a receive context will cache.
-/// Additional packets will either be dropped or cause a different packet to be dropped
-/// from the cache.
-/// Larger values consume more memory but provide better reliability and DDOS resistance.
-pub(crate) const MAX_UNASSOCIATED_PACKETS: usize = 32;
-/// The maximum number of fragments of unassociated packets that a receive context will
-/// cache.
-/// All unassociated fragments share the same buffer, when it fills up additional
-/// fragments will be dropped or cause other fragments to be dropped from the cache.
-/// Larger values consume more memory but provide better reliability and DDOS resistance.
-pub(crate) const MAX_UNASSOCIATED_FRAGMENTS: usize = 32 * 32;
-/// The maximum number of `NoiseXKBobHandshakeState` that a receive context will cache.
-/// These are extremely large and since Alice has not been authenticated we put a hard
-/// limit to how many we cache.
-/// Larger values consume more memory but provide better reliability and DDOS resistance.
-pub(crate) const MAX_UNASSOCIATED_HANDSHAKE_STATES: usize = 32;
-
-/// The maximum size a packet that is not associated to a session may be.
-/// Excludes the size of headers for fragmentation.
-pub(crate) const MAX_UNASSOCIATED_PACKET_SIZE: usize = NoiseXKPattern1::MAX_SIZE - HEADER_SIZE;
-
-/*
-XKhfs+psk2:
-    <- s
-    ...
-    -> e, es, e1
-    <- e, ee, ekem1, psk
-    -> s, se
-*/
-/*
-KKpsk0:
-    -> s
-    <- s
-    ...
-    -> psk, e, es, ss
-    <- e, ee, se
-*/
-/*
-Header:
-    [0..4]   recipient key id
--- start AES(ck_es * h_e_e1_p) encrypted block --
-    [4]      fragment count (1..255)
-    [5]      fragment number (0..254)
-    [6]      reserved zero
--- start AES-GCM Nonce --
-    [7]      packet type
-    [8..16]  64-bit counter or packet id
-*/
-/// The first packet in Noise_XK exchange containing Alice's ephemeral keys, key id,
-/// and a random symmetric key to protect header fragmentation fields for this session.
-#[repr(C, packed)]
-pub(crate) struct NoiseXKPattern1 {
-    pub header: [u8; HEADER_SIZE],
-    /// -- start prologue --
-    pub alice_key_id: [u8; SESSION_ID_SIZE],
-    /// -- end prologue --
-    pub noise_e: [u8; P384_PUBLIC_KEY_SIZE],
-    /// -- start AES-GCM(k_es) encrypted section
-    pub noise_e1: [u8; KYBER_PUBLICKEYBYTES],
-    /// -- end encrypted section
-    pub e1_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-    pub payload: [u8; RATCHET_SIZE + RATCHET_SIZE + AES_GCM_TAG_SIZE + ChallengeResponse::SIZE],
-}
-
-#[repr(C, packed)]
-pub(crate) struct ChallengeResponse {
-    pub challenge_counter: [u8; CHALLENGE_COUNTER_SIZE],
-    pub challenge_mac: [u8; CHALLENGE_MAC_SIZE],
-    pub challenge_pow: [u8; CHALLENGE_POW_SIZE],
-}
-
-impl NoiseXKPattern1 {
-    pub const PROLOGUE_START: usize = HEADER_SIZE;
-    pub const PROLOGUE_END: usize = Self::PROLOGUE_START + SESSION_ID_SIZE;
-    pub const E1_ENC_START: usize = Self::PROLOGUE_END + P384_PUBLIC_KEY_SIZE;
-    pub const E1_AUTH_START: usize = Self::E1_ENC_START + KYBER_PUBLICKEYBYTES;
-    pub const P_ENC_START: usize = Self::E1_AUTH_START + AES_GCM_TAG_SIZE;
-
-    pub const MIN_SIZE: usize = Self::P_ENC_START + AES_GCM_TAG_SIZE + ChallengeResponse::SIZE;
-    pub const MAX_SIZE: usize = Self::MIN_SIZE + RATCHET_SIZE + RATCHET_SIZE;
-}
-impl ChallengeResponse {
-    pub const SIZE: usize = CHALLENGE_COUNTER_SIZE + CHALLENGE_MAC_SIZE + CHALLENGE_POW_SIZE;
-}
-
-#[repr(C, packed)]
-pub(crate) struct BobDOSChallenge {
-    pub header: [u8; HEADER_SIZE],
-    pub alice_key_id: [u8; SESSION_ID_SIZE],
-    pub challenge_counter: [u8; CHALLENGE_COUNTER_SIZE],
-    pub challenge_mac: [u8; CHALLENGE_MAC_SIZE],
-    pub prior_challenge_pow: [u8; CHALLENGE_POW_SIZE],
-}
-
-impl BobDOSChallenge {
-    pub const SIZE: usize = HEADER_SIZE + SESSION_ID_SIZE + CHALLENGE_COUNTER_SIZE + CHALLENGE_MAC_SIZE + CHALLENGE_POW_SIZE;
-}
-
-/// The response to NoiseXKPattern1 containing Bob's ephemeral keys.
-#[repr(C, packed)]
-pub(crate) struct NoiseXKPattern2 {
-    pub header: [u8; HEADER_SIZE],
-    pub noise_e: [u8; P384_PUBLIC_KEY_SIZE],
-    /// -- start AES-GCM(k_es_ee) encrypted section
-    pub noise_ekem1: [u8; KYBER_CIPHERTEXTBYTES],
-    /// -- end encrypted section
-    pub ekem1_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-    /// -- start AES-GCM(k_es_ee_ekem1_psk) encrypted section
-    pub bob_key_id: [u8; SESSION_ID_SIZE],
-    /// -- end encrypted section
-    pub p_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-}
-
-impl NoiseXKPattern2 {
-    pub const EKEM1_ENC_START: usize = HEADER_SIZE + P384_PUBLIC_KEY_SIZE;
-    pub const EKEM1_AUTH_START: usize = Self::EKEM1_ENC_START + KYBER_CIPHERTEXTBYTES;
-    pub const P_ENC_START: usize = Self::EKEM1_AUTH_START + AES_GCM_TAG_SIZE;
-    pub const P_AUTH_START: usize = Self::P_ENC_START + SESSION_ID_SIZE;
-    pub const P_AUTH_END: usize = Self::P_AUTH_START + AES_GCM_TAG_SIZE;
-    pub const SIZE: usize = Self::P_AUTH_END;
-}
-
-/// Alice's final response containing her identity (she already knows Bob's) and meta-data.
-/// While Alice's response does match what is described in this struct,
-/// this struct is unused because it would contain variable length fields.
-/// It is present here for documentation purposes.
-#[repr(C, packed)]
-pub(crate) struct NoiseXKPattern3 {
-    pub header: [u8; HEADER_SIZE],
-    /// -- start AES-GCM(k_es_ee_ekem1_psk) encrypted section
-    pub noise_s: [u8; P384_PUBLIC_KEY_SIZE],
-    /// -- end encrypted section
-    pub s_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-    /// -- start AES-GCM(k_es_ee_ekem1_psk_se) encrypted section
-    pub alice_blob: [u8; 0],
-    /// -- end encrypted section
-    pub p_gcm_tag: [u8; AES_GCM_TAG_SIZE],
-}
-impl NoiseXKPattern3 {
-    pub const MIN_SIZE: usize = HEADER_SIZE + P384_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
-    pub const MAX_SIZE: usize = MAX_NOISE_HANDSHAKE_SIZE;
-}
-
-#[repr(C, packed)]
-pub(crate) struct NoiseKKPattern1or2 {
-    pub header: [u8; HEADER_SIZE],
-    pub noise_e: [u8; P384_PUBLIC_KEY_SIZE],
-    pub key_id: [u8; SESSION_ID_SIZE],
-    pub gcm_tag: [u8; AES_GCM_TAG_SIZE],
-    pub kek_tag: [u8; AES_GCM_TAG_SIZE],
-}
-impl NoiseKKPattern1or2 {
-    pub const ENC_START: usize = HEADER_SIZE + P384_PUBLIC_KEY_SIZE;
-    pub const AUTH_START: usize = Self::ENC_START + SESSION_ID_SIZE;
-    pub const AUTH_END: usize = Self::AUTH_START + AES_GCM_TAG_SIZE;
-    pub const SIZE: usize = Self::AUTH_END + AES_GCM_TAG_SIZE;
-}
-
-// Annotate only these structs as being compatible with byte_array_as_proto_buffer(). These structs
-// are packed flat buffers containing only byte or byte array fields, making them safe to treat
-// this way even on architectures that require type size aligned access.
-pub(crate) trait ProtocolFlatBuffer {}
-impl ProtocolFlatBuffer for NoiseXKPattern1 {}
-impl ProtocolFlatBuffer for NoiseXKPattern2 {}
-impl ProtocolFlatBuffer for NoiseKKPattern1or2 {}
-impl ProtocolFlatBuffer for BobDOSChallenge {}
-impl ProtocolFlatBuffer for ChallengeResponse {}
-
-#[inline(always)]
-pub(crate) fn byte_array_as_proto_buffer<B: ProtocolFlatBuffer>(b: &[u8]) -> &B {
-    assert!(b.len() >= size_of::<B>());
-    unsafe { &*b.as_ptr().cast() }
-}
-
-#[inline(always)]
-pub(crate) fn byte_array_as_proto_buffer_mut<B: ProtocolFlatBuffer>(b: &mut [u8]) -> &mut B {
-    assert!(b.len() >= size_of::<B>());
-    unsafe { &mut *b.as_mut_ptr().cast() }
-}
-/// Trick rust into letting us use a hasher that returns more than 64 bits.
-pub(crate) struct ShaHasher<'a, ShaImpl: HashSha512>(pub &'a mut ShaImpl);
-impl<'a, ShaImpl: HashSha512> Hasher for ShaHasher<'a, ShaImpl> {
-    fn finish(&self) -> u64 {
-        panic!()
-    }
-    fn write(&mut self, bytes: &[u8]) {
-        self.0.update(bytes)
-    }
-}
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index 378eb78..d90298b 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -1,10 +1,15 @@
+use arrayvec::ArrayVec;
 use zeroize::Zeroizing;
 
-use crate::crypto::secure_eq;
+use crate::crypto::*;
 use crate::proto::*;
 /// A ratchet key and fingerprint,
 /// along with the length of the ratchet chain the keys were derived from.
 ///
+/// Implements constant time equality.
+/// The hash implementation only uses the ratchet fingerprint.
+/// Any operation involving the ratchet key must take constant time.
+///
 /// Corresponds to the Ratchet Key and Ratchet Fingerprint described in Section 3.
 #[derive(Clone, Eq)]
 pub struct RatchetState {
@@ -14,13 +19,19 @@ pub struct RatchetState {
 }
 impl PartialEq for RatchetState {
     fn eq(&self, other: &Self) -> bool {
-        secure_eq(&self.key, &other.key)
-            & (self.chain_len == other.chain_len)
-            & match (self.fingerprint.as_ref(), other.fingerprint.as_ref()) {
-                (Some(rf1), Some(rf2)) => secure_eq(rf1, rf2),
-                (None, None) => true,
-                _ => false,
-            }
+        let ret = match (self.fingerprint.as_ref(), other.fingerprint.as_ref()) {
+            (Some(rf1), Some(rf2)) => secure_eq(rf1, rf2),
+            (None, None) => true,
+            _ => false,
+        };
+        ret & secure_eq(&self.key, &other.key) & (self.chain_len == other.chain_len)
+    }
+}
+impl std::hash::Hash for RatchetState {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        if let Some(rf) = &self.fingerprint {
+            state.write_u64(u64::from_ne_bytes(rf[..8].try_into().unwrap()))
+        }
     }
 }
 impl RatchetState {
@@ -41,29 +52,23 @@ impl RatchetState {
             chain_len: 0,
         }
     }
-    //pub fn new_from_otp<Hmac: HmacSha512>(otp: &[u8]) -> RatchetState {
-    //    let mut buffer = Vec::new();
-    //    buffer.push(1);
-    //    buffer.extend(LABEL_OTP_TO_RATCHET);
-    //    buffer.push(0x00);
-    //    buffer.extend((2u16 * 512u16).to_be_bytes());
-    //    let r1 = Hmac::hmac(otp, &buffer);
-    //    buffer[0] = 2;
-    //    let r2 = Hmac::hmac(otp, &buffer);
-    //    Self::new(
-    //        Zeroizing::new(r1[..RATCHET_SIZE].try_into().unwrap()),
-    //        Zeroizing::new(r2[..RATCHET_SIZE].try_into().unwrap()),
-    //        1,
-    //    )
-    //}
+    pub fn new_from_otp<Hmac: HmacSha512>(otp: &[u8]) -> RatchetState {
+        let mut buffer = ArrayVec::<u8, 23>::new();
+        buffer.push(1);
+        buffer.extend(*LABEL_OTP_TO_RATCHET);
+        buffer.push(0x00);
+        buffer.extend((1024u16).to_be_bytes());
 
-    pub fn new_initial_states() -> (RatchetState, Option<RatchetState>) {
-        (RatchetState::empty(), None)
+        let mut hmac = Hmac::new();
+        let mut output = Zeroizing::new([0u8; HASHLEN]);
+        hmac.hash(otp, &buffer, &mut output);
+        let rk = Zeroizing::new(output[..RATCHET_SIZE].try_into().unwrap());
+        buffer[0] = 2;
+        hmac.hash(otp, &buffer, &mut output);
+        let rf = Zeroizing::new(output[..RATCHET_SIZE].try_into().unwrap());
+
+        Self::new(rk, rf, 1)
     }
-    //pub fn new_otp_states<Hmac: HashSha512>(otp: &[u8]) -> (RatchetState, Option<RatchetState>) {
-    //    (RatchetState::new_from_otp::<Hmac>(otp), None)
-    //}
-
     pub fn is_empty(&self) -> bool {
         self.fingerprint.is_none()
     }
@@ -74,3 +79,87 @@ impl RatchetState {
         self.fingerprint.as_deref()
     }
 }
+impl Default for RatchetState {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+/// A pair of ratchet states.
+/// It is expected that an instance of this object will be saved to a storage device per-peer,
+/// and be restore-able via the `ApplicationLayer` trait.
+///
+/// This corresponds to the possible values of abstract variables `rf` and `rk` found in Section 4.3.
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct RatchetStates {
+    pub state1: RatchetState,
+    pub state2: Option<RatchetState>,
+}
+impl RatchetStates {
+    pub fn new(state1: RatchetState, state2: Option<RatchetState>) -> Self {
+        Self { state1, state2 }
+    }
+    pub fn new_initial_states() -> Self {
+        Self { state1: RatchetState::empty(), state2: None }
+    }
+    pub fn new_otp_states<Hmac: HmacSha512>(otp: &[u8]) -> Self {
+        Self {
+            state1: RatchetState::new_from_otp::<Hmac>(otp),
+            state2: None,
+        }
+    }
+}
+impl Default for RatchetStates {
+    fn default() -> Self {
+        Self::new_initial_states()
+    }
+}
+
+/// A set of references to ratchet states specifying how a remote peer's persistent
+/// storage should be updated.
+///
+/// There should be only up to two ratchet states saved to storage at a time per peer.
+/// Every time a new ratchet state is generated, a previous ratchet state will be deleted.
+///
+/// These are sensitive values should they ought to be securely stored.
+#[derive(Clone)]
+pub struct RatchetUpdate<'a> {
+    /// The ratchet key and fingerprint to store in the first slot.
+    pub state1: &'a RatchetState,
+    /// The ratchet key and fingerprint to store in the second slot.
+    pub state2: Option<&'a RatchetState>,
+    /// Whether `state1` is a brand new ratchet state, or if it was previously saved.
+    pub state1_was_just_added: bool,
+    /// A previous ratchet key and fingerprint that now must be deleted from storage.
+    /// This will have been a previously given value of `state1` or `state2`.
+    pub deleted_state1: Option<&'a RatchetState>,
+    /// A previous ratchet key and fingerprint that now must be deleted from storage.
+    /// It is extremely rare that this field is occupied.
+    pub deleted_state2: Option<&'a RatchetState>,
+}
+impl<'a> RatchetUpdate<'a> {
+    pub fn to_states(&self) -> RatchetStates {
+        RatchetStates::new(self.state1.clone(), self.state2.cloned())
+    }
+    pub fn added_fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
+        if self.state1_was_just_added {
+            self.state1.fingerprint()
+        } else {
+            None
+        }
+    }
+    pub fn deleted_fingerprint1(&self) -> Option<&[u8; RATCHET_SIZE]> {
+        if let Some(rs) = &self.deleted_state1 {
+            rs.fingerprint()
+        } else {
+            None
+        }
+    }
+    pub fn deleted_fingerprint2(&self) -> Option<&[u8; RATCHET_SIZE]> {
+        if let Some(rs) = &self.deleted_state2 {
+            rs.fingerprint()
+        } else {
+            None
+        }
+    }
+}
diff --git a/src/ratchet_state_old.rs b/src/ratchet_state_old.rs
deleted file mode 100644
index 73519e6..0000000
--- a/src/ratchet_state_old.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-
-use std::num::NonZeroU64;
-
-#[derive(Clone, PartialEq, Eq)]
-pub enum RatchetState {
-    Null,
-    Empty,
-    NonEmpty(NonEmptyRatchetState),
-}
-use RatchetState::*;
-use zeroize::Zeroizing;
-
-use crate::proto::RATCHET_SIZE;
-impl RatchetState {
-    pub fn new_nonempty(key: Zeroizing<[u8; RATCHET_SIZE]>, fingerprint: Zeroizing<[u8; RATCHET_SIZE]>, chain_len: NonZeroU64) -> Self {
-        NonEmpty(NonEmptyRatchetState { key, fingerprint, chain_len })
-    }
-    pub fn new_initial_states() -> [RatchetState; 2] {
-        [RatchetState::Empty, RatchetState::Null]
-    }
-    pub fn is_null(&self) -> bool {
-        matches!(self, Null)
-    }
-    pub fn is_empty(&self) -> bool {
-        matches!(self, Empty)
-    }
-    pub fn nonempty(&self) -> Option<&NonEmptyRatchetState> {
-        match self {
-            NonEmpty(rs) => Some(rs),
-            _ => None,
-        }
-    }
-    pub fn chain_len(&self) -> u64 {
-        self.nonempty().map_or(0, |rs| rs.chain_len.get())
-    }
-    //pub fn fingerprint(&self) -> Option<&[u8; RATCHET_SIZE]> {
-    //    self.nonempty().map(|rs| rs.fingerprint.as_ref())
-    //}
-    //pub fn key(&self) -> Option<&[u8; RATCHET_SIZE]> {
-    //    const ZERO_KEY: [u8; RATCHET_SIZE] = [0u8; RATCHET_SIZE];
-    //    match self {
-    //        Null => None,
-    //        Empty => Some(&ZERO_KEY),
-    //        NonEmpty(rs) => Some(rs.key.as_ref()),
-    //    }
-    //}
-}
-/// A ratchet key and fingerprint,
-/// along with the length of the ratchet chain the keys were derived from.
-#[derive(Clone, PartialEq, Eq)]
-pub struct NonEmptyRatchetState {
-    pub key: Zeroizing<[u8; RATCHET_SIZE]>,
-    pub fingerprint: Zeroizing<[u8; RATCHET_SIZE]>,
-    pub chain_len: NonZeroU64,
-}
diff --git a/src/result.rs b/src/result.rs
index c070bc9..15b023d 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::applicationlayer::ApplicationLayer;
+use crate::application::ApplicationLayer;
 use crate::zeta::Session;
 
 /// An error that can occur when attempting to open a session.
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index e2f0e5c..a780b72 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -1,12 +1,10 @@
 use std::marker::PhantomData;
 
-use arrayvec::ArrayVec;
 use zeroize::Zeroizing;
 
-use crate::crypto::aes::{HighThroughputAesGcmPool, LowThroughputAesGcm, AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE};
-use crate::crypto::sha512::{HashSha512, HmacSha512};
+use crate::crypto::*;
 use crate::proto::*;
-use crate::{applicationlayer::ApplicationLayer, crypto::aes::AES_256_KEY_SIZE};
+use crate::application::ApplicationLayer;
 
 pub struct SymmetricState<App: ApplicationLayer> {
     k: Zeroizing<[u8; AES_256_KEY_SIZE]>,
diff --git a/src/symmetric_state_old.rs b/src/symmetric_state_old.rs
deleted file mode 100644
index 264fc45..0000000
--- a/src/symmetric_state_old.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-use crate::crypto::aes::AES_256_KEY_SIZE;
-use crate::crypto::sha512::HmacSha512;
-
-use crate::proto::NOISE_HASHLEN;
-
-#[derive(Clone)]
-pub(crate) struct SymmetricState {
-    chaining_key: Secret<NOISE_HASHLEN>,
-    token_counter: u8,
-}
-
-impl SymmetricState {
-    pub(crate) fn new(h: [u8; NOISE_HASHLEN]) -> Self {
-        Self { chaining_key: Secret(h), token_counter: b'P' }
-    }
-    /// Corresponds to Noise `MixKey`.
-    pub(crate) fn mix_key(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) {
-        let mut next_ck = Secret::new();
-
-        self.kbkdf(hm, input_key_material, self.label(), 2, next_ck.as_mut(), None, None);
-        self.token_counter += 1;
-
-        self.chaining_key.overwrite(&next_ck);
-        // We don't need a key at this step of Noise, so generating that key and calling
-        // `InitializeKey` would be completely pointless.
-    }
-    /// Corresponds to Noise `MixKey` followed by `InitializeKey`.
-    pub(crate) fn mix_key_initialize_key(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) -> Secret<AES_256_KEY_SIZE> {
-        let mut next_ck = Secret::new();
-        let mut temp_k = [0u8; NOISE_HASHLEN];
-
-        self.kbkdf(hm, input_key_material, self.label(), 2, next_ck.as_mut(), Some(&mut temp_k), None);
-        self.token_counter += 1;
-
-        self.chaining_key.overwrite(&next_ck);
-        Secret::from_bytes_then_delete(&mut temp_k[..AES_256_KEY_SIZE])
-    }
-    /// Corresponds to Noise `MixKeyAndHash`.
-    pub(crate) fn mix_key_and_hash(&mut self, hm: &mut impl HmacSha512, input_key_material: &[u8]) -> [u8; NOISE_HASHLEN] {
-        let mut next_ck = Secret::new();
-        let mut temp_h = [0u8; NOISE_HASHLEN];
-
-        self.kbkdf(hm, input_key_material, self.label(), 3, next_ck.as_mut(), Some(&mut temp_h), None);
-        self.token_counter += 1;
-
-        self.chaining_key.overwrite(&next_ck);
-        temp_h
-    }
-    /// Corresponds to Noise `MixKeyAndHash` followed by `InitializeKey`.
-    pub(crate) fn mix_key_and_hash_initialize_key(
-        &mut self,
-        hm: &mut impl HmacSha512,
-        input_key_material: &[u8],
-    ) -> ([u8; NOISE_HASHLEN], Secret<AES_256_KEY_SIZE>) {
-        let mut next_ck = Secret::new();
-        let mut temp_h = [0u8; NOISE_HASHLEN];
-        let mut temp_k = [0u8; NOISE_HASHLEN];
-
-        self.kbkdf(
-            hm,
-            input_key_material,
-            self.label(),
-            3,
-            next_ck.as_mut(),
-            Some(&mut temp_h),
-            Some(&mut temp_k),
-        );
-        self.token_counter += 1;
-
-        self.chaining_key.overwrite(&next_ck);
-        (temp_h, Secret::from_bytes_then_delete(&mut temp_k[..AES_256_KEY_SIZE]))
-    }
-    /// Get an additional symmetric key (ASK) that is a collision resistant hash of the transcript,
-    /// is forward secrect and is cryptographically independent from all other produced keys.
-    /// Based on Noise's unstable ASK mechanism, using KBKDF instead of HKDF.
-    /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
-    pub(crate) fn get_ask2(
-        &self,
-        hm: &mut impl HmacSha512,
-        label: u8,
-        noise_h: &[u8; NOISE_HASHLEN],
-    ) -> (Secret<AES_256_KEY_SIZE>, Secret<AES_256_KEY_SIZE>) {
-        let mut temp_k1 = [0u8; NOISE_HASHLEN];
-        let mut temp_k2 = [0u8; NOISE_HASHLEN];
-        self.kbkdf(hm, noise_h, [b'A', b'S', b'K', label], 2, &mut temp_k1, Some(&mut temp_k2), None);
-        (
-            Secret::from_bytes_then_delete(&mut temp_k1[..AES_256_KEY_SIZE]),
-            Secret::from_bytes_then_delete(&mut temp_k2[..AES_256_KEY_SIZE]),
-        )
-    }
-    /// Corresponds to Noise `Split`.
-    pub(crate) fn split(self, hm: &mut impl HmacSha512) -> (Secret<AES_256_KEY_SIZE>, Secret<AES_256_KEY_SIZE>) {
-        let mut temp_k1 = [0u8; NOISE_HASHLEN];
-        let mut temp_k2 = [0u8; NOISE_HASHLEN];
-        self.kbkdf(hm, &[], self.label(), 2, &mut temp_k1, Some(&mut temp_k2), None);
-        // Normally KBKDF would not truncate to derive the correct length of AES keys,
-        // but Noise specifies that the AES keys be truncated from NOISE_HASHLEN to AES_256_KEY_SIZE.
-        (
-            Secret::from_bytes_then_delete(&mut temp_k1[..AES_256_KEY_SIZE]),
-            Secret::from_bytes_then_delete(&mut temp_k2[..AES_256_KEY_SIZE]),
-        )
-    }
-    fn label(&self) -> [u8; 4] {
-        [b'Z', b'S', b'S', self.token_counter]
-    }
-    /// HMAC-SHA512 key derivation based on KBKDF Counter Mode:
-    /// https://csrc.nist.gov/publications/detail/sp/800-108/rev-1/final.
-    /// Cryptographically this isn't meaningfully different from
-    /// `HKDF(self.chaining_key, input_key_material)` but this is how NIST rolls.
-    /// These are the values we have assigned to the 4 variables involved in their KDF:
-    /// * K_IN = `input_key_material`
-    /// * Label = `label`
-    /// * Context = `self.chaining_key`
-    /// * L = `num_outputs*512u16`
-    /// We have intentionally made every input small and fixed size to avoid unnecessary complexity
-    /// and data representation ambiguity.
-    fn kbkdf(
-        &self,
-        hm: &mut impl HmacSha512,
-        input_key_material: &[u8],
-        label: [u8; 4],
-        num_outputs: u16,
-        output1: &mut [u8; NOISE_HASHLEN],
-        output2: Option<&mut [u8; NOISE_HASHLEN]>,
-        output3: Option<&mut [u8; NOISE_HASHLEN]>,
-    ) {
-        let l = &(num_outputs * 512u16).to_be_bytes();
-
-        hm.reset(input_key_material);
-        hm.update(&[1, label[0], label[1], label[2], label[3], 0x00]);
-        hm.update(self.chaining_key.as_ref());
-        hm.update(l);
-        hm.finish(output1);
-        if let Some(output2) = output2 {
-            hm.reset(input_key_material);
-            hm.update(&[2, label[0], label[1], label[2], label[3], 0x00]);
-            hm.update(self.chaining_key.as_ref());
-            hm.update(l);
-            hm.finish(output2);
-        }
-        if let Some(output3) = output3 {
-            hm.reset(input_key_material);
-            hm.update(&[3, label[0], label[1], label[2], label[3], 0x00]);
-            hm.update(self.chaining_key.as_ref());
-            hm.update(l);
-            hm.finish(output3);
-        }
-    }
-}
diff --git a/src/zeta.rs b/src/zeta.rs
index 79e7eba..0278fb7 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -10,21 +10,14 @@ use std::sync::{Arc, Mutex, RwLock, Weak};
 use zeroize::Zeroizing;
 
 use crate::antireplay::Window;
-use crate::applicationlayer::ApplicationLayer;
-use crate::applicationlayer::RatchetUpdate;
+use crate::application::*;
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
 use crate::zssp::{log, ContextInner, SessionQueue};
-//use crate::context::{log, ContextInner, SessionMap};
-use crate::crypto::aes::*;
-use crate::crypto::kyber1024::{
-    Kyber1024PrivateKey, KYBER_CIPHERTEXT_SIZE, KYBER_PLAINTEXT_SIZE, KYBER_PUBLIC_KEY_SIZE,
-};
-use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
-use crate::crypto::sha512::{HashSha512, HmacSha512};
+use crate::crypto::*;
 use crate::fragged::Fragged;
 use crate::indexed_heap::BinaryHeapIndex;
 use crate::proto::*;
-use crate::ratchet_state::RatchetState;
+use crate::ratchet_state::{RatchetState, RatchetStates};
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
 use crate::symmetric_state::SymmetricState;
 #[cfg(feature = "logging")]
@@ -167,10 +160,6 @@ impl Keys {
     }
 }
 
-/// Corresponds to the tuple of values the Transition Algorithms send to the remote peer in Section 4.3.
-//#[derive(Clone)]
-//pub(crate) struct Packet(pub u32, pub [u8; AES_GCM_IV_SIZE], pub Vec<u8>);
-
 /// Corresponds to State A_1 of the Zeta State Machine found in Section 4.1.
 #[derive(Clone)]
 pub(crate) struct StateA1<App: ApplicationLayer> {
@@ -181,16 +170,17 @@ pub(crate) struct StateA1<App: ApplicationLayer> {
     x1: ArrayVec<u8, HEADERED_HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE>,
 }
 
+pub(crate) struct StateA3 {
+    identity: ArrayVec<u8, IDENTITY_MAX_SIZE>,
+    x3: ArrayVec<u8, HEADERED_HANDSHAKE_COMPLETION_MAX_SIZE>,
+}
+
+
 /// Corresponds to the ZKE Automata found in Section 4.1 - Definition 2.
 pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
     Null,
     A1(Box<StateA1<App>>),
-    A3 {
-        identity: ArrayVec<u8, IDENTITY_MAX_SIZE>,
-        kid_send: u32,
-        nonce: [u8; AES_GCM_IV_SIZE],
-        x3: ArrayVec<u8, HEADERED_HANDSHAKE_COMPLETION_MAX_SIZE>,
-    },
+    A3(Box<StateA3>),
     S1,
     S2,
     R1 {
@@ -232,6 +222,34 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         *i = j;
         App::PublicKey::from_bytes((pub_key).try_into().unwrap())
     }
+    fn write_e_no_init<const CAP: usize>(
+        &mut self,
+        hash: &mut App::Hash,
+        hmac: &mut App::HmacHash,
+        rng: &Mutex<App::Rng>,
+        packet: &mut ArrayVec<u8, CAP>,
+    ) -> App::KeyPair {
+        let e_secret = App::KeyPair::generate(rng.lock().unwrap().deref_mut());
+        let pub_key = e_secret.public_key_bytes();
+        packet.extend(pub_key);
+        self.mix_hash(hash, &pub_key);
+        self.mix_key_no_init(hmac, &pub_key);
+        e_secret
+    }
+    fn read_e_no_init(
+        &mut self,
+        hash: &mut App::Hash,
+        hmac: &mut App::HmacHash,
+        i: &mut usize,
+        packet: &[u8],
+    ) -> Option<App::PublicKey> {
+        let j = *i + P384_PUBLIC_KEY_SIZE;
+        let pub_key = &packet[*i..j];
+        self.mix_hash(hash, pub_key);
+        self.mix_key_no_init(hmac, pub_key);
+        *i = j;
+        App::PublicKey::from_bytes((pub_key).try_into().unwrap())
+    }
     fn mix_dh(&mut self, hmac: &mut App::HmacHash, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
         let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
         if secret.agree(&remote, &mut ecdh_secret) {
@@ -241,6 +259,15 @@ impl<App: ApplicationLayer> SymmetricState<App> {
             None
         }
     }
+    fn mix_dh_no_init(&mut self, hmac: &mut App::HmacHash, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
+        let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
+        if secret.agree(&remote, &mut ecdh_secret) {
+            self.mix_key_no_init(hmac, ecdh_secret.as_ref());
+            Some(())
+        } else {
+            None
+        }
+    }
 }
 
 /// Generate a random local key id that is currently unused.
@@ -335,9 +362,9 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     identity: &[u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
-    let (ratchet_state1, ratchet_state2) = app
+    let RatchetStates{state1, state2} = app
         .restore_by_identity(&s_remote, &session_data)
-        .map_err(|e| OpenError::RatchetIoError(e))?;
+        .map_err(|e| OpenError::RatchetIoError(e))?.unwrap_or_default();
 
     let mut session_queue = ctx.session_queue.lock().unwrap();
     let mut session_map = ctx.session_map.write().unwrap();
@@ -351,8 +378,8 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         &ctx.rng,
         &s_remote,
         kid_recv,
-        &ratchet_state1,
-        ratchet_state2.as_ref(),
+        &state1,
+        state2.as_ref(),
         identity,
     )
     .ok_or(OpenError::InvalidPublicKey)?;
@@ -382,8 +409,8 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         window: Window::new(),
         state_machine_lock: Mutex::new(()),
         state: RwLock::new(MutableState {
-            ratchet_state1: ratchet_state1.clone(),
-            ratchet_state2: ratchet_state2.clone(),
+            ratchet_state1: state1.clone(),
+            ratchet_state2: state2.clone(),
             key_creation_counter: 0,
             key_index: true,
             keys: [DuplexKey::default(), DuplexKey::default()],
@@ -709,8 +736,8 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 state1: &new_ratchet_state,
                 state2: ratchet_to_preserve,
                 state1_was_just_added: true,
-                state_deleted1: ratchet_to_delete,
-                state_deleted2: None,
+                deleted_state1: ratchet_to_delete,
+                deleted_state2: None,
             },
         );
         if let Err(e) = result {
@@ -746,12 +773,10 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 // This return is unreachable.
                 return Err(byzantine_fault!(FailedAuth, true));
             };
-            state.beta = ZetaAutomata::A3 {
+            state.beta = ZetaAutomata::A3(Box::new(StateA3 {
                 identity: a1.identity.clone(),
                 x3: x3.clone(),
-                kid_send: kid_send.get(),
-                nonce,
-            };
+            }));
             resend_timer
         };
         drop(kex_lock);
@@ -845,8 +870,9 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     if let Some(session_data) = session_data {
         let result = app.restore_by_identity(&s_remote, &session_data);
         match result {
-            Ok((ratchet_state1, ratchet_state2)) => {
-                if (&zeta.ratchet_state != &ratchet_state1) & (Some(&zeta.ratchet_state) != ratchet_state2.as_ref()) {
+            Ok(rss) => {
+                let RatchetStates { state1, state2 } = rss.unwrap_or_default();
+                if (&zeta.ratchet_state != &state1) & (Some(&zeta.ratchet_state) != state2.as_ref()) {
                     if !responder_disallows_downgrade && zeta.ratchet_state.fingerprint().is_none() {
                         // TODO: add some kind of warning callback or signal.
                     } else {
@@ -875,8 +901,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                         state1: &new_ratchet_state,
                         state2: None,
                         state1_was_just_added: true,
-                        state_deleted1: Some(&ratchet_state1),
-                        state_deleted2: ratchet_state2.as_ref(),
+                        deleted_state1: Some(&state1),
+                        deleted_state2: state2.as_ref(),
                     },
                 );
                 if let Err(e) = result {
@@ -1003,8 +1029,8 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
                         state1: &state.ratchet_state1,
                         state2: None,
                         state1_was_just_added: false,
-                        state_deleted1: state.ratchet_state2.as_ref(),
-                        state_deleted2: None,
+                        deleted_state1: state.ratchet_state2.as_ref(),
+                        deleted_state2: None,
                     },
                 );
                 if let Err(e) = result {
@@ -1164,7 +1190,7 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
             ZetaAutomata::A1(_) | ZetaAutomata::A3 { .. } => {
                 let identity = match &state.beta {
                     ZetaAutomata::A1(a1) => &a1.identity,
-                    ZetaAutomata::A3 { identity, .. } => identity,
+                    ZetaAutomata::A3(a3) => &a3.identity,
                     _ => unreachable!(),
                 };
                 if matches!(&state.beta, ZetaAutomata::A1(_)) {
@@ -1302,9 +1328,9 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
                     send(&mut a1.x1.clone(), None);
                     return Some(resend_next);
                 }
-                ZetaAutomata::A3 { x3, .. } => {
+                ZetaAutomata::A3(a3) => {
                     log!(app, ResentX3(session));
-                    send(&mut x3.clone(), Some(&session.hk_send));
+                    send(&mut a3.x3.clone(), Some(&session.hk_send));
                     return Some(resend_next);
                 }
                 ZetaAutomata::S1 => {
@@ -1471,8 +1497,8 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
                 state1: &new_ratchet_state,
                 state2: Some(&state.ratchet_state1),
                 state1_was_just_added: true,
-                state_deleted1: state.ratchet_state2.as_ref(),
-                state_deleted2: None,
+                deleted_state1: state.ratchet_state2.as_ref(),
+                deleted_state2: None,
             },
         );
         if let Err(e) = result {
@@ -1605,8 +1631,8 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
                     state1: &new_ratchet_state,
                     state2: None,
                     state1_was_just_added: true,
-                    state_deleted1: Some(&state.ratchet_state1),
-                    state_deleted2: state.ratchet_state2.as_ref(),
+                    deleted_state1: Some(&state.ratchet_state1),
+                    deleted_state2: state.ratchet_state2.as_ref(),
                 },
             );
             if let Err(e) = result {
diff --git a/src/zssp copy.rs b/src/zssp copy.rs
deleted file mode 100644
index 413c38d..0000000
--- a/src/zssp copy.rs	
+++ /dev/null
@@ -1,2704 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
-* License, v. 2.0. If a copy of the MPL was not distributed with this
-* file, You can obtain one at https://mozilla.org/MPL/2.0/.
-*
-* (c) ZeroTier, Inc.
-* https://www.zerotier.com/
-*/
-// ZSSP: ZeroTier Secure Session Protocol
-// FIPS compliant Noise_XK with Jedi powers (Kyber1024) and built-in attack-resistant large payload (fragmentation) support.
-
-use std::cmp::Reverse;
-use std::collections::HashMap;
-use std::hash::Hash;
-use std::num::{NonZeroU32, NonZeroU64};
-use std::ops::DerefMut;
-use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
-use std::sync::{Arc, Mutex, MutexGuard, RwLock, Weak};
-
-use crate::crypto::aes::{AesDec, AesEnc};
-use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
-use crate::crypto::pqc_kyber::KYBER_SECRETKEYBYTES;
-use crate::crypto::rand_core::RngCore;
-use crate::crypto::sha512::{HmacSha512, HashSha512};
-
-use crate::error::{FaultType, OpenError, ReceiveError, SendError};
-use crate::frag_cache::UnassociatedFragCache;
-use crate::fragged::{Assembled, Fragged};
-use crate::handshake_cache::UnassociatedHandshakeCache;
-use crate::indexed_heap::{BinaryHeapIndex, IndexedBinaryHeap};
-use crate::log_event::LogEvent;
-use crate::proto::*;
-use crate::symmetric_state::SymmetricState;
-use crate::{applicationlayer::*, RatchetState};
-
-/// Session context for local application.
-///
-/// Each application using ZSSP must create an instance of this to own sessions and
-/// defragment incoming packets that are not yet associated with a session.
-///
-/// Internally this is just a clonable Arc, so it can be safely shared with multiple threads.
-pub struct Context<Application: ApplicationLayer>(pub Arc<ContextInner<Application>>);
-impl<Application: ApplicationLayer> Clone for Context<Application> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-pub struct ContextInner<Application: ApplicationLayer> {
-    static_keypair: Application::KeyPair,
-    unassociated_defrag_cache: Mutex<UnassociatedFragCache<Application::IncomingPacketBuffer>>,
-    unassociated_handshake_states: UnassociatedHandshakeCache<Application>,
-    /// `session_queue -> state_machine_lock -> state -> session_map`
-    session_queue: Mutex<IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>>,
-    session_map: RwLock<HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>>,
-    challenge_counter: AtomicU64,
-    challenge_antireplay_window: [AtomicU64; CHALLENGE_COUNTER_WINDOW_MAX_OOO],
-    challenge_salt: [u8; CHALLENGE_SALT_SIZE],
-    rng: Mutex<Application::Rng>,
-}
-
-/// Result generated by the context packet receive function, with possible payloads.
-pub enum ReceiveResult<'b, Application: ApplicationLayer> {
-    /// Packet superficially appeared valid but is not associated with a session yet.
-    /// This can occur because the packet was only a fragment of a larger packet,
-    /// or if it was a control packet that does not go through full Noise authentication.
-    Unassociated,
-    /// Packet was authentic and belongs to this specific session.
-    Session(Arc<Session<Application>>, SessionEvent<'b>),
-    /// Packet was a part of a handshake, and while it superficially appeared valid the application
-    /// explicitly rejected it.
-    /// Relates to callbacks `check_allow_incoming_session`, `hello_requires_recognized_ratchet`
-    /// and `check_accept_session`.
-    Rejected,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum SessionEvent<'b> {
-    /// The received packet was valid, and it contained the necessary keys to fully establish a new
-    /// session with Alice, the handshake initiator.
-    ///
-    /// If the session Arc returned is dropped, the session with this peer will be immediately
-    /// terminated. Save the session Arc to some long lived datastructure to keep it alive.
-    NewSession,
-    /// When Alice calls `Context::open`, a session will be created, but Bob will not yet have
-    /// received this session. They will have to successfully complete a handshake first.
-    ///
-    /// Alice will receive this return value when the received packet confirms both parties
-    /// have completed the initial handshake and now have a shared session with each other.
-    /// If according to the upper protocol, Bob is the first party to send data, it is possible for
-    /// Alice to start receiving data from Bob before this value is returned.
-    ///
-    /// This return value can only occur once per session, only for session objects that were
-    /// created with `Context::open`.
-    Established,
-    /// Bob explicitly refused to establish a session with Alice, and sent us an error code.
-    /// The application should immediately drop this session as Bob will not allow us to connect.
-    ///
-    /// This return value cannot occur after a session is fully established.
-    Rejected,
-    /// The received packet was valid and a data payload was decoded and authenticated.
-    Data(&'b mut [u8]),
-    /// The received packet was some authentic protocol control packet. No action needs to be taken.
-    Control,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum IncomingSessionAction {
-    Allow,
-    Challenge,
-    Drop,
-}
-
-/// ZeroTier Secure Session Protocol (ZSSP) Session
-///
-/// A FIPS/NIST compliant variant of Noise_XK with hybrid Kyber1024 PQ data forward secrecy.
-pub struct Session<Application: ApplicationLayer> {
-    /// An arbitrary application defined object associated with each session.
-    pub application_data: Application::SessionData,
-    /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
-    pub was_bob: bool,
-    /// The receive context associated with this session,
-    /// only this context can receive messages from the remote peer.
-    context: Weak<ContextInner<Application>>,
-    /// Handle into the session queue for changing the update timer.
-    queue_idx: BinaryHeapIndex,
-
-    remote_static_key: Application::PublicKey,
-    send_counter: AtomicU64,
-    /// This bool signals to all threads to stop incrementing the counter and instead error out.
-    session_has_expired: AtomicBool,
-    /// The following is a ring buffer of previously seen counter values, where we use the counter's
-    /// value as the index of the head of the ring buffer.
-    counter_antireplay_window: [AtomicU64; COUNTER_WINDOW_MAX_OOO],
-    /// Enforces atomicity of state machine transitions.
-    /// There is a standard locking sequence,
-    /// it goes `session_queue -> state_machine_lock -> state -> session_map`.
-    /// Any lock can be skipped but they must be locked in that order.
-    state_machine_lock: Mutex<()>,
-    state: RwLock<SessionMutableState<Application>>,
-    defrag: [Mutex<Fragged<Application::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
-    header_send_cipher: Application::PrpEnc,
-    header_receive_cipher: Application::PrpDec,
-    kex_send_cipher: Mutex<Option<Application::AeadEnc>>,
-    kex_receive_cipher: Mutex<Option<Application::AeadDec>>,
-    /// Pre-computed rekeying values.
-    noise_kk_ss: Secret<P384_ECDH_SHARED_SECRET_SIZE>,
-    noise_kk_local_init_h: [u8; HASHLEN],
-    noise_kk_remote_init_h: [u8; HASHLEN],
-}
-/// `AesGcm` is not threadsafe, but it is threadsafe when inside a `Mutex`.
-unsafe impl<Application: ApplicationLayer> Send for Session<Application> {}
-unsafe impl<Application: ApplicationLayer> Sync for Session<Application> {}
-
-/// Session state may only be mutated during atomic transitions of the offer state machine.
-struct SessionMutableState<Application: ApplicationLayer> {
-    ratchet_states: [RatchetState; 2],
-    /// For OOO rekeying reliability we allow our version of Noise CipherState to hold the last two
-    /// session keys, instead of just the most recent one.
-    cipher_states: [Option<SessionKey<Application>>; 2],
-    /// This is the index of `noise_cipher_state` that contains the most recent key.
-    /// It will be attached to fragment headers to help with OOO transport.
-    current_key: usize,
-    /// This defines the exact state of the offer state machine we are in.
-    outgoing_offer: OfferStateMachine<Application>,
-}
-
-/// These offer enums form a state machine.
-/// Documented below are the only legal transitions for this state machine.
-/// A session is initialized with an `outgoing_offer` of either NoiseXKPattern1 or Normal.
-enum OfferStateMachine<Application: ApplicationLayer> {
-    Normal {
-        timeout: i64,
-    }, // -> NoiseKKPattern1, NoiseKKPattern2
-    /// This state uses a lot of memory so we put it on the heap.
-    NoiseXKPattern1or3(Box<NoiseXKAliceHandshake<Application>>), // -> Normal
-    NoiseKKPattern1 {
-        next_retry_time: AtomicI64,
-        timeout: i64,
-        new_key_id: NonZeroU32,
-        noise_e_secret: Application::KeyPair,
-        noise_message: [u8; NoiseKKPattern1or2::SIZE],
-        noise_ck: SymmetricState,
-        noise_h_pskep: [u8; HASHLEN],
-    }, // -> NoiseKKPattern2, KeyConfirm
-    NoiseKKPattern2 {
-        next_retry_time: AtomicI64,
-        timeout: i64,
-        noise_message: [u8; NoiseKKPattern1or2::SIZE],
-        kex_send_key: Secret<AES_GCM_KEY_SIZE>,
-    }, // -> Normal
-    KeyConfirm {
-        next_retry_time: AtomicI64,
-        timeout: i64,
-    }, // -> Normal
-    Null,
-}
-
-pub(crate) struct NoiseXKBobHandshakeState<Application: ApplicationLayer> {
-    /// Can never be Null.
-    ratchet_state: RatchetState,
-    remote_key_id: NonZeroU32,
-    local_key_id: NonZeroU32,
-    header_receive_key: Secret<AES_GCM_KEY_SIZE>,
-    header_send_key: Secret<AES_GCM_KEY_SIZE>,
-    noise_h_ee1peekem1pskp: [u8; HASHLEN],
-    noise_e_secret: Application::KeyPair,
-    noise_ck_eseeekem1psk: SymmetricState,
-    noise_k_eseeekem1psk: Secret<AES_GCM_KEY_SIZE>,
-    noise_pattern3_defrag: Mutex<Fragged<Application::IncomingPacketBuffer, MAX_FRAGMENTS>>,
-}
-
-struct NoiseXKAliceHandshake<Application: ApplicationLayer> {
-    next_retry_time: AtomicI64,
-    timeout: i64,
-    /// A secure random number put in the header of Alice's fragments to identify them.
-    /// If a DDOS attacker could guess this they could block Alice starting the handshake.
-    local_key_id: NonZeroU32,
-    alice_identity_blob: Application::LocalIdentityBlob,
-    offer: NoiseXKAliceHandshakeState<Application>,
-}
-
-enum NoiseXKAliceHandshakeState<Application: ApplicationLayer> {
-    NoiseXKPattern1 {
-        noise_h_ee1p: [u8; HASHLEN],
-        noise_e_secret: Application::KeyPair,
-        noise_e1_secret: Secret<KYBER_SECRETKEYBYTES>,
-        noise_ck_es: SymmetricState,
-        /// ZSSP assumes an unreliable, out-of-order physical transport environment, so for that
-        /// reason we have to resend key offers.
-        noise_message: [u8; NoiseXKPattern1::MAX_SIZE],
-        noise_message_len: usize,
-        message_id: u64,
-    },
-    NoiseXKPattern3 {
-        noise_message: [u8; NoiseXKPattern3::MAX_SIZE],
-        noise_message_len: usize,
-    },
-}
-
-struct SessionKey<Application: ApplicationLayer> {
-    remote_key_id: NonZeroU32,
-    local_key_id: NonZeroU32,
-    /// Pool of reusable sending ciphers.
-    receive_cipher_pool: [Mutex<Application::AeadDec>; 8],
-    /// Pool of reusable receiving ciphers.
-    send_cipher_pool: [Mutex<Application::AeadEnc>; 8],
-    /// Rekey at or after this counter.
-    rekey_at_counter: u64,
-    /// Hard error when this counter value is reached or exceeded.
-    expire_at_counter: u64,
-}
-
-macro_rules! byzantine_fault {
-    ($name:expr, $is_natural:ident) => {
-        ReceiveError::ByzantineFault {
-            file: file!(),
-            line: line!(),
-            error: $name,
-            is_naturally_occurring: $is_natural,
-        }
-    };
-}
-
-impl<Application: ApplicationLayer> Context<Application> {
-    /// Create a new session context.
-    pub fn new(static_keypair: Application::KeyPair, mut rng: Application::Rng) -> Self {
-        debug_assert!(Application::REKEY_AFTER_TIME_MAX_JITTER_MS > 0, "Invalid protocol constant");
-        let mut challenge_salt = [0u8; CHALLENGE_SALT_SIZE];
-        rng.fill_bytes(&mut challenge_salt);
-        Self(Arc::new(ContextInner {
-            static_keypair,
-            unassociated_defrag_cache: Mutex::new(UnassociatedFragCache::new()),
-            unassociated_handshake_states: UnassociatedHandshakeCache::new(),
-            session_map: RwLock::new(HashMap::new()),
-            session_queue: Mutex::new(IndexedBinaryHeap::new()),
-            challenge_counter: AtomicU64::new(INIT_COUNTER),
-            challenge_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
-            challenge_salt,
-            rng: Mutex::new(rng),
-        }))
-    }
-
-    /// Perform periodic background service and cleanup tasks.
-    ///
-    /// This returns the number of milliseconds until it should be called again. The caller should
-    /// try to satisfy this but small variations in timing of up to +/- a second or two are not
-    /// a problem.
-    ///
-    /// * `send_to` - Function to get a sender and an MTU to send something over an active session
-    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
-    ///   with remote peers (although both of these properties would help reliability slightly).
-    ///   Used to determine if any current handshakes should be resent or timed-out, or if a session
-    ///   should rekey.
-    pub fn service<SendFn: FnMut(&mut [u8]) -> bool>(
-        &self,
-        app: &Application,
-        mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
-        current_time: i64,
-    ) -> i64 {
-        let retry_next = current_time.saturating_add(Application::RETRY_INTERVAL_MS);
-        let mut next_service_time = 2 * Application::RETRY_INTERVAL_MS;
-
-        let mut session_queue = self.0.session_queue.lock().unwrap();
-        // This update system takes heavy advantage of the fact that sessions only need to be updated
-        // either roughly every second or roughly every hour. That big gap allows for minor optimizations.
-        // If the gap changes (unlikely) this code may need to be rewritten.
-        while let Some((session, timer, queue_idx)) = session_queue.peek() {
-            if timer.0 >= current_time {
-                next_service_time = next_service_time.min(timer.0 - current_time);
-                break;
-            }
-            let session = match session.upgrade() {
-                Some(s) => s,
-                _ => {
-                    session_queue.remove(queue_idx);
-                    continue;
-                }
-            };
-            let state = session.state.read().unwrap();
-            use OfferStateMachine::*;
-            let next_timer = match &state.outgoing_offer {
-                Normal { timeout, .. } => {
-                    if *timeout <= current_time {
-                        drop(state);
-                        if let Some((send, _)) = send_to(&session) {
-                            let result = initiate_rekey(&self.0, &session, send, current_time);
-                            if result.is_ok() {
-                                app.event_log(LogEvent::ServiceKKStart(&session), current_time);
-                            }
-                            result.unwrap_or(retry_next)
-                        } else {
-                            retry_next
-                        }
-                    } else {
-                        *timeout
-                    }
-                }
-                // If there's an outstanding attempt to open a session, retransmit this
-                // periodically in case the initial packet doesn't make it.
-                NoiseXKPattern1or3(handshake_state) => {
-                    if let Some(ts) = process_timer(&handshake_state.next_retry_time, Application::RETRY_INTERVAL_MS, current_time) {
-                        ts
-                    } else {
-                        // We have to eventually time out NoiseXKPattern3 because of unreliable network conditions.
-                        if handshake_state.timeout <= current_time {
-                            drop(state);
-                            let _kex_lock = session.state_machine_lock.lock().unwrap();
-                            let mut state = session.state.write().unwrap();
-                            let ratchet_state = state.ratchet_states.clone();
-                            // Since we dropped the lock we must re-check if we are in the correct state.
-                            if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
-                                if handshake_state.timeout <= current_time {
-                                    app.event_log(LogEvent::ServiceXKTimeout(&session), current_time);
-                                    handshake_state.reinitialize(
-                                        &session,
-                                        &ratchet_state,
-                                        &mut self.0.session_map.write().unwrap(),
-                                        &mut self.0.rng.lock().unwrap(),
-                                        current_time,
-                                    );
-                                }
-                            }
-                        } else if let Some((mut send, mut mtu)) = send_to(&session) {
-                            mtu = mtu.max(MIN_TRANSPORT_MTU);
-                            match &handshake_state.offer {
-                                NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, message_id, .. } => {
-                                    app.event_log(LogEvent::ServiceXK1Resend(&session), current_time);
-                                    // We are in state NoiseXKPattern1 so resend noise_pattern1.
-                                    send_with_fragmentation(
-                                        &mut send,
-                                        mtu,
-                                        &mut noise_message.clone()[..*noise_message_len],
-                                        PACKET_TYPE_NOISE_XK_PATTERN_1,
-                                        None,
-                                        *message_id,
-                                        None::<&Application::PrpEnc>,
-                                    );
-                                }
-                                NoiseXKAliceHandshakeState::NoiseXKPattern3 { noise_message, noise_message_len, .. } => {
-                                    app.event_log(LogEvent::ServiceXK3Resend(&session), current_time);
-                                    send_with_fragmentation(
-                                        &mut send,
-                                        mtu,
-                                        &mut noise_message.clone()[..*noise_message_len],
-                                        PACKET_TYPE_NOISE_XK_PATTERN_3,
-                                        state.cipher_states[0].as_ref().map(|k| k.remote_key_id),
-                                        0,
-                                        Some(&session.header_send_cipher),
-                                    );
-                                }
-                            }
-                        }
-                        retry_next
-                    }
-                }
-                NoiseKKPattern1 { next_retry_time, timeout, noise_message, .. } | NoiseKKPattern2 { next_retry_time, timeout, noise_message, .. } => {
-                    if let Some(ts) = process_timer(next_retry_time, Application::RETRY_INTERVAL_MS, current_time) {
-                        ts
-                    } else {
-                        if *timeout <= current_time {
-                            app.event_log(LogEvent::ServiceKKTimeout(&session), current_time);
-                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
-                            drop(state);
-                            session.expire_inner(&self.0, &mut session_queue);
-                        } else {
-                            let packet_type = if let NoiseKKPattern1 { .. } = &state.outgoing_offer {
-                                app.event_log(LogEvent::ServiceKK1Resend(&session), current_time);
-                                PACKET_TYPE_NOISE_KK_PATTERN_1
-                            } else {
-                                app.event_log(LogEvent::ServiceKK2Resend(&session), current_time);
-                                PACKET_TYPE_NOISE_KK_PATTERN_2
-                            };
-                            if let Some((send, _)) = send_to(&session) {
-                                let _ = session.send_control(&state, send, packet_type, noise_message);
-                            }
-                        }
-                        retry_next
-                    }
-                }
-                KeyConfirm { next_retry_time, timeout, .. } => {
-                    if let Some(ts) = process_timer(next_retry_time, Application::RETRY_INTERVAL_MS, current_time) {
-                        ts
-                    } else {
-                        if *timeout <= current_time {
-                            app.event_log(LogEvent::ServiceKeyConfirmTimeout(&session), current_time);
-                            next_retry_time.store(i64::MAX, Ordering::Relaxed);
-                            drop(state);
-                            session.expire_inner(&self.0, &mut session_queue);
-                        } else {
-                            app.event_log(LogEvent::ServiceKeyConfirmResend(&session), current_time);
-                            if let Some((send, _)) = send_to(&session) {
-                                let _ = session.send_control(&state, send, PACKET_TYPE_KEY_CONFIRM, &[]);
-                            }
-                        }
-                        retry_next
-                    }
-                }
-                Null => retry_next,
-            };
-            session_queue.change_priority(queue_idx, Reverse(next_timer));
-        }
-        drop(session_queue);
-
-        self.0
-            .unassociated_defrag_cache
-            .lock()
-            .unwrap()
-            .check_for_expiry(Application::INITIAL_OFFER_TIMEOUT_MS, current_time);
-        self.0.unassociated_handshake_states.service(current_time);
-
-        next_service_time
-    }
-
-    /// Create a new session and send initial packet(s) to other side.
-    ///
-    /// This will return SendError::DataTooLarge if the combined size of the metadata and the local
-    /// static public blob (as retrieved from the application layer) exceed MAX_INIT_PAYLOAD_SIZE.
-    ///
-    /// * `app` - Application layer instance
-    /// * `send` - Function to be called to send one or more initial packets to the remote being
-    ///   contacted
-    /// * `mtu` - MTU for initial packets
-    /// * `remote_static_key` - Remote side's static public NIST P-384 key
-    /// * `application_data` - Arbitrary data meaningful to the application to include with session
-    ///   object
-    /// * `ratchet_state` - The last saved and confirmed ratchet state associated with this remote
-    ///   peer, or None if we do not have one.
-    /// * `local_identity_blob` - Payload to be sent to Bob that contains the information necessary
-    ///   for the upper protocol to authenticate and approve of Alice's identity.
-    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
-    /// with the remote peer. Used to determine when this offer should be resent.
-    pub fn open(
-        &self,
-        app: &Application,
-        mut send: impl FnMut(&mut [u8]) -> bool,
-        mut mtu: usize,
-        remote_static_key: Application::PublicKey,
-        application_data: Application::SessionData,
-        local_identity_blob: Application::LocalIdentityBlob,
-        current_time: i64,
-    ) -> Result<Arc<Session<Application>>, OpenError<Application::StorageError>> {
-        mtu = mtu.max(MIN_TRANSPORT_MTU);
-        if local_identity_blob.as_ref().len() > MAX_IDENTITY_BLOB_SIZE {
-            return Err(OpenError::DataTooLarge);
-        }
-        let result = app.restore_by_identity(&remote_static_key, &application_data, current_time);
-        match result {
-            Ok(ratchet_states) => {
-                let sha512 = &mut Application::Hash::new();
-
-                let mut noise_kk_ss = Secret::new();
-                if !self.0.static_keypair.agree(&remote_static_key, noise_kk_ss.as_mut()) {
-                    return Err(OpenError::InvalidPublicKey);
-                }
-                let noise_kk_local_init_h = mix_hash(sha512, &INITIAL_H_REKEY, self.0.static_keypair.public_key_bytes());
-                let noise_kk_local_init_h = mix_hash(sha512, &noise_kk_local_init_h, remote_static_key.as_bytes());
-                let noise_kk_remote_init_h = mix_hash(sha512, &INITIAL_H_REKEY, remote_static_key.as_bytes());
-                let noise_kk_remote_init_h = mix_hash(sha512, &noise_kk_remote_init_h, self.0.static_keypair.public_key_bytes());
-
-                let mut session_queue = self.0.session_queue.lock().unwrap();
-                let mut session_map = self.0.session_map.write().unwrap();
-                let local_key_id = generate_key_id(&session_map, &mut self.0.rng.lock().unwrap());
-                // Begin Noise XKhfs+psk2.
-                let (offer, a2b_header_key, b2a_header_key) = NoiseXKAliceHandshake::<Application>::initialize(
-                    local_key_id,
-                    &remote_static_key,
-                    &ratchet_states,
-                    &mut self.0.rng.lock().unwrap(),
-                )?;
-                let handshake_state = Box::new(NoiseXKAliceHandshake {
-                    next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-                    timeout: current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS),
-                    local_key_id,
-                    alice_identity_blob: local_identity_blob,
-                    offer,
-                });
-                if let NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, message_id, .. } = &handshake_state.offer {
-                    send_with_fragmentation(
-                        &mut send,
-                        mtu,
-                        &mut noise_message.clone()[..*noise_message_len],
-                        PACKET_TYPE_NOISE_XK_PATTERN_1,
-                        None,
-                        *message_id,
-                        None::<&Application::PrpEnc>,
-                    );
-                }
-
-                let queue_idx = session_queue.reserve_index();
-                let session = Arc::new(Session {
-                    context: Arc::downgrade(&self.0),
-                    queue_idx,
-                    application_data,
-                    remote_static_key,
-                    send_counter: AtomicU64::new(INIT_COUNTER),
-                    session_has_expired: AtomicBool::new(false),
-                    counter_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
-                    state_machine_lock: Mutex::new(()),
-                    state: RwLock::new(SessionMutableState {
-                        ratchet_states: ratchet_states.clone(),
-                        cipher_states: [None, None],
-                        // Points at 1 until the first key is confirmed.
-                        current_key: 1,
-                        outgoing_offer: OfferStateMachine::NoiseXKPattern1or3(handshake_state),
-                    }),
-                    header_send_cipher: Application::PrpEnc::new(a2b_header_key.as_ref()),
-                    header_receive_cipher: Application::PrpDec::new(b2a_header_key.as_ref()),
-                    kex_receive_cipher: Mutex::new(None),
-                    kex_send_cipher: Mutex::new(None),
-                    noise_kk_ss: noise_kk_ss.clone(),
-                    noise_kk_local_init_h,
-                    noise_kk_remote_init_h,
-                    defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
-                    was_bob: false,
-                });
-                session_map.insert(local_key_id, (Arc::downgrade(&session), false));
-                session_queue.push_reserved(
-                    queue_idx,
-                    Arc::downgrade(&session),
-                    Reverse(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-                );
-
-                Ok(session)
-            }
-            Err(e) => Err(OpenError::RatchetIoError(e)),
-        }
-    }
-
-    /// Receive, authenticate, decrypt, and process a physical wire packet.
-    ///
-    /// The check_allow_incoming_session function is called when an initial Noise_XK init message is
-    /// received. This is before anything is known about the caller. A return value of true proceeds
-    /// with negotiation. False drops the packet and ignores the inbound attempt.
-    ///
-    /// The check_accept_session function is called at the end of negotiation for an incoming
-    /// session with the caller's static public blob. It must return the P-384 static public key
-    /// extracted from the supplied blob and application data. A return of Some() accepts the
-    /// session and will always result in a new session ReceiveResult being returned.
-    ///
-    /// * `app` - Interface to application using ZSSP
-    /// * `check_allow_incoming_session` - Function to call to check whether an unidentified new
-    ///   session should be accepted
-    /// * `check_accept_session` - Function to accept sessions after final negotiation.
-    ///   The second argument is the identity blob that the remote peer sent us. The application
-    ///   must verify this identity is associated with the remote peer's static key.
-    ///   The third argument is the ratchet chain length, or ratchet count.
-    ///   To prevent desync, if this function returns (Some(_), _), no other open session with the
-    ///   same remote peer must exist.
-    /// * `send_unassociated_reply` - Function to send reply packets directly when no session exists
-    /// * `send_unassociated_mtu` - MTU for unassociated replies
-    /// * `send_to` - Function to get senders for existing sessions, permitting MTU and path lookup
-    /// * `remote_address` - Whatever the remote address is, as long as you can Hash it
-    /// * `data_buf` - Buffer to receive decrypted and authenticated object data (an error is
-    ///   returned if too small)
-    /// * `incoming_physical_packet_buf` - Buffer containing incoming wire packet
-    ///   (receive() takes ownership)
-    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
-    ///   with the remote peer. Used to check the state of local offers we may currently have or want
-    ///   to put in-flight.
-    pub fn receive<'a, SendFn: FnMut(&mut [u8]) -> bool>(
-        &self,
-        app: &Application,
-        check_allow_incoming_session: impl FnOnce() -> IncomingSessionAction,
-        check_accept_session: impl FnOnce(&Application::PublicKey, &[u8], u64) -> (Option<(bool, Application::SessionData)>, bool),
-        mut send_unassociated_reply: impl FnMut(&mut [u8]) -> bool,
-        mut send_unassociated_mtu: usize,
-        mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
-        remote_address: &impl Hash,
-        data_buf: &'a mut [u8],
-        mut incoming_physical_packet_buf: Application::IncomingPacketBuffer,
-        current_time: i64,
-    ) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::StorageError>> {
-        send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
-        let incoming_physical_packet: &mut [u8] = incoming_physical_packet_buf.as_mut();
-        let incoming_physical_packet_len = incoming_physical_packet.len();
-        if incoming_physical_packet_len < MIN_PACKET_SIZE {
-            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-        }
-
-        // The first section parses the header and looks up relevant state information. If it's a DATA
-        // or NOP packet it gets handled right here, otherwise we pull out a set of variables and
-        // continue to the logic that handles KEX and session control packets.
-
-        let mut assembled_packet = Assembled::new(); // needs to outlive the block below
-        let mut incoming = None;
-        let (session, packet_type, fragments) = {
-            let local_key_id = incoming_physical_packet[0..SESSION_ID_SIZE].try_into().unwrap();
-            // `from_ne_bytes` because this id was generated locally.
-            if let Some(local_key_id) = NonZeroU32::new(u32::from_ne_bytes(local_key_id)) {
-                let session_map = self.0.session_map.read().unwrap();
-                if let Some((Some(session), key_index)) = session_map.get(&local_key_id).map(|r| (r.0.upgrade(), r.1 as usize)) {
-                    drop(session_map);
-                    session.header_receive_cipher.decrypt_in_place(
-                        (&mut incoming_physical_packet[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END])
-                            .try_into()
-                            .unwrap(),
-                    );
-                    let (fragment_count, fragment_no, packet_type, incoming_counter, header_nonce) = parse_packet_header(incoming_physical_packet);
-                    // Handle replay protection.
-                    if PACKET_TYPE_RANGE_TRANSPORT.contains(&packet_type) {
-                        // For DOS resistant reply-protection we need to check that the given counter is
-                        // in the window of valid counters immediately.
-                        // But for packets larger than 1 fragment we can't actually record the
-                        // counter as received until we've authenticated the packet.
-                        // So we check the counter window twice, and only update it the second time
-                        // after the packet has been authenticated.
-                        if !session.check_receive_window(incoming_counter) {
-                            // This can occur naturally if packets arrive way out of order, or
-                            // if they are duplicates.
-                            // This can also be naturally triggered if Bob has just successfully
-                            // received the first session key and is reject all of Alice's resends.
-                            // This can also occur if a session was manually expired, but not
-                            // dropped, and the remote party is still sending us data.
-                            return Err(byzantine_fault!(FaultType::ExpiredCounter, true));
-                        }
-                        if packet_type != PACKET_TYPE_DATA {
-                            // This is a control packet.
-                            if fragment_count != 1 || fragment_no > 0 {
-                                return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                            }
-                            return receive_control_fragment(
-                                self,
-                                session,
-                                app,
-                                send_to,
-                                packet_type,
-                                incoming_counter,
-                                incoming_physical_packet_buf.as_mut(),
-                                current_time,
-                            );
-                        }
-                    } else if packet_type == PACKET_TYPE_NOISE_XK_PATTERN_2 {
-                        // We need to reject fragments marked with this type if they are sent out
-                        // of sequence, since an attacker is able to replay them.
-                        match &session.state.read().unwrap().outgoing_offer {
-                            OfferStateMachine::NoiseXKPattern1or3(handshake_state) => match &handshake_state.offer {
-                                NoiseXKAliceHandshakeState::NoiseXKPattern1 { .. } => {
-                                    if incoming_counter >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
-                                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                                    }
-                                }
-                                // This error can occur naturally if Bob's initial reply to Alice had a
-                                // resend that was delayed massively and arrived out of order.
-                                _ => return Err(byzantine_fault!(FaultType::OutOfSequence, true)),
-                            },
-                            _ => return Err(byzantine_fault!(FaultType::OutOfSequence, false)),
-                        };
-                    } else if packet_type == PACKET_TYPE_NOISE_XK_PATTERN_3 {
-                        // This can be triggered if Bob successfully received a session key and
-                        // needs to reject all of Alice's resends of PACKET_TYPE_NOISE_XK_PATTERN_3.
-                        return Err(byzantine_fault!(FaultType::OutOfSequence, true));
-                    } else {
-                        return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                    }
-                    // Handle defragmentation.
-                    let fragments = if fragment_count > 1 {
-                        let idx = incoming_counter as usize % session.defrag.len();
-                        session.defrag[idx].lock().unwrap().assemble(
-                            header_nonce,
-                            incoming_physical_packet_buf,
-                            fragment_no,
-                            fragment_count,
-                            &mut assembled_packet,
-                        );
-                        if assembled_packet.is_empty() {
-                            // We have not yet authenticated the sender so we do not report
-                            // receiving a packet from them.
-                            return Ok(ReceiveResult::Unassociated);
-                        } else {
-                            assembled_packet.as_ref()
-                        }
-                    } else {
-                        std::array::from_ref(&incoming_physical_packet_buf)
-                    };
-                    // Handle DATA in the fastest path when we have a session.
-                    if packet_type == PACKET_TYPE_DATA {
-                        let state = session.state.read().unwrap();
-                        // The error here can occur because the other party is using a brand new
-                        // session key that we have not received yet.
-                        let key = state.cipher_states[key_index]
-                            .as_ref()
-                            .ok_or(byzantine_fault!(FaultType::OutOfSequence, true))?;
-                        let mut c = key.get_receive_cipher(incoming_counter);
-                        c.set_iv(&create_message_nonce(packet_type, incoming_counter));
-
-                        let mut data_len = 0;
-
-                        // Decrypt fragments 0..N-1 where N is the number of fragments.
-                        for f in fragments[..(fragments.len() - 1)].iter() {
-                            let f: &[u8] = f.as_ref();
-                            debug_assert!(f.len() >= HEADER_SIZE);
-                            let current_frag_data_start = data_len;
-                            data_len += f.len() - HEADER_SIZE;
-                            if data_len > data_buf.len() {
-                                return Err(ReceiveError::DataBufferTooSmall);
-                            }
-                            c.decrypt(&f[HEADER_SIZE..], &mut data_buf[current_frag_data_start..data_len]);
-                        }
-
-                        // Decrypt final fragment (or only fragment if not fragmented)
-                        let current_frag_data_start = data_len;
-                        let last_fragment = fragments.last().unwrap().as_ref();
-                        if last_fragment.len() < (HEADER_SIZE + AES_GCM_TAG_SIZE) {
-                            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                        }
-                        data_len += last_fragment.len() - (HEADER_SIZE + AES_GCM_TAG_SIZE);
-                        if data_len > data_buf.len() {
-                            return Err(ReceiveError::DataBufferTooSmall);
-                        }
-                        let payload_end = last_fragment.len() - AES_GCM_TAG_SIZE;
-                        c.decrypt(&last_fragment[HEADER_SIZE..payload_end], &mut data_buf[current_frag_data_start..data_len]);
-
-                        let aead_authentication_ok = c.finish_decrypt(&last_fragment[payload_end..].try_into().unwrap());
-                        drop(c);
-                        drop(state);
-
-                        if !aead_authentication_ok {
-                            return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                        }
-                        if !session.update_receive_window(incoming_counter) {
-                            // This can be naturally triggered because Bob has just
-                            // successfully received a session key and needs to reject
-                            // all of Alice's resends.
-                            // This can also occur naturally if some part of the outer
-                            // system is duplicating the packets being sent to us.
-                            // We are safely deduplicating them here.
-                            return Err(byzantine_fault!(FaultType::ExpiredCounter, true));
-                        }
-                        // Packet fully authenticated
-                        return Ok(ReceiveResult::Session(session, SessionEvent::Data(&mut data_buf[..data_len])));
-                    } else if packet_type == PACKET_TYPE_NOISE_XK_PATTERN_2 {
-                        (Some(session), packet_type, fragments)
-                    } else {
-                        unreachable!()
-                    }
-                } else {
-                    drop(session_map);
-                    // Check for and handle PACKET_TYPE_ALICE_NOISE_XK_PATTERN_3
-                    incoming = self.0.unassociated_handshake_states.get(local_key_id);
-                    if let Some(incoming) = incoming.as_ref() {
-                        Application::PrpDec::new(incoming.header_receive_key.as_ref()).decrypt_in_place(
-                            (&mut incoming_physical_packet[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END])
-                                .try_into()
-                                .unwrap(),
-                        );
-                        let (fragment_count, fragment_no, packet_type, _, header_nonce) = parse_packet_header(incoming_physical_packet);
-                        app.event_log(
-                            LogEvent::ReceiveUnassociatedFragment(fragment_count, fragment_no, packet_type),
-                            current_time,
-                        );
-                        if packet_type != PACKET_TYPE_NOISE_XK_PATTERN_3 {
-                            return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                        }
-                        let fragments = if fragment_count > 1 {
-                            incoming.noise_pattern3_defrag.lock().unwrap().assemble(
-                                header_nonce,
-                                incoming_physical_packet_buf,
-                                fragment_no,
-                                fragment_count,
-                                &mut assembled_packet,
-                            );
-                            if !assembled_packet.is_empty() {
-                                assembled_packet.as_ref()
-                            } else {
-                                return Ok(ReceiveResult::Unassociated);
-                            }
-                        } else {
-                            std::array::from_ref(&incoming_physical_packet_buf)
-                        };
-                        // We must guarantee that this incoming handshake is processed once and only
-                        // once. This prevents catastrophic nonce reuse caused by multithreading.
-                        if self.0.unassociated_handshake_states.remove(local_key_id) {
-                            (None, PACKET_TYPE_NOISE_XK_PATTERN_3, fragments)
-                        } else {
-                            return Ok(ReceiveResult::Unassociated);
-                        }
-                    } else {
-                        // This can occur naturally because either Bob's incoming_sessions cache got
-                        // full so Alice's incoming session was dropped, or the session this packet
-                        // was for was dropped by the application.
-                        return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
-                    }
-                }
-            } else {
-                let (fragment_count, fragment_no, packet_type, _, header_nonce) = parse_packet_header(incoming_physical_packet);
-                app.event_log(
-                    LogEvent::ReceiveUnassociatedFragment(fragment_count, fragment_no, packet_type),
-                    current_time,
-                );
-                if packet_type != PACKET_TYPE_NOISE_XK_PATTERN_1 && packet_type != PACKET_TYPE_BOB_DOS_CHALLENGE {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-                let fragments = if fragment_count > 1 {
-                    self.0.unassociated_defrag_cache.lock().unwrap().assemble(
-                        header_nonce,
-                        remote_address,
-                        incoming_physical_packet_len - HEADER_SIZE,
-                        incoming_physical_packet_buf,
-                        fragment_no,
-                        fragment_count,
-                        Application::RETRY_INTERVAL_MS,
-                        current_time,
-                        &mut assembled_packet,
-                    );
-                    if !assembled_packet.is_empty() {
-                        assembled_packet.as_ref()
-                    } else {
-                        return Ok(ReceiveResult::Unassociated);
-                    }
-                } else {
-                    std::array::from_ref(&incoming_physical_packet_buf)
-                };
-                (None, packet_type, fragments)
-            }
-        };
-
-        debug_assert!(!fragments.is_empty());
-        debug_assert!(incoming.is_none() || session.is_none());
-
-        let message = &mut [0u8; MAX_NOISE_HANDSHAKE_SIZE];
-        let message_size = assemble_fragments_into::<Application>(fragments, message)?;
-        if message_size < MIN_PACKET_SIZE {
-            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-        }
-
-        use OfferStateMachine::*;
-        match packet_type {
-            PACKET_TYPE_NOISE_XK_PATTERN_1 => {
-                // Alice (remote) --> Bob (local)
-                // -> e, es, e1
-                app.event_log(LogEvent::ReceiveUncheckedXK1, current_time);
-
-                if session.is_some() || incoming.is_some() {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-                if !(NoiseXKPattern1::MIN_SIZE..=NoiseXKPattern1::MAX_SIZE).contains(&message_size) {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                // The message id must be the first 8 bytes of the gcm tag.
-                // This forces the message id to be authenticated along with the entire message.
-                let p_auth_end = message_size - ChallengeResponse::SIZE;
-                if message[8..16] != message[p_auth_end - 8..p_auth_end] {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                let p_size = p_auth_end - NoiseXKPattern1::P_ENC_START - AES_GCM_TAG_SIZE;
-                let total_ratchet_fingerprints = p_size / RATCHET_SIZE;
-                if p_size % RATCHET_SIZE != 0 || total_ratchet_fingerprints > 2 {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-
-                let noise_pattern1: &NoiseXKPattern1 = byte_array_as_proto_buffer(message);
-                if let Some(remote_key_id) = NonZeroU32::new(u32::from_ne_bytes(noise_pattern1.alice_key_id)) {
-                    let sha512 = &mut Application::Hash::new();
-                    // Let application filter incoming connection attempts by whatever criteria it wants.
-                    // This should ideally prevent ZSSP from wasting time on DDOS attacks.
-                    match check_allow_incoming_session() {
-                        IncomingSessionAction::Allow => {}
-                        IncomingSessionAction::Challenge => {
-                            let response: &ChallengeResponse = byte_array_as_proto_buffer(&message[p_auth_end..message_size]);
-                            let counter = u64::from_be_bytes(response.challenge_counter.try_into().unwrap());
-
-                            sha512.reset();
-                            let mut hasher = ShaHasher(sha512);
-                            let mut output = [0u8; HASHLEN];
-                            hasher.0.update(&response.challenge_counter);
-                            remote_address.hash(&mut hasher);
-                            hasher.0.update(&self.0.challenge_salt);
-                            hasher.0.finish(&mut output);
-                            let is_valid = self.check_challenge_window(counter)
-                                && secure_eq(&output[..CHALLENGE_MAC_SIZE], &response.challenge_mac)
-                                && verify_pow::<Application>(hasher.0, &message[p_auth_end..message_size])
-                                && self.update_challenge_window(counter);
-                            app.event_log(LogEvent::ReceiveCheckXK1Challenge(is_valid), current_time);
-                            if !is_valid {
-                                // Alice failed the challenge so issue them a new challenge.
-                                let mut challenge_buffer = [0u8; BobDOSChallenge::SIZE];
-                                let challenge: &mut BobDOSChallenge = byte_array_as_proto_buffer_mut(&mut challenge_buffer);
-                                challenge.alice_key_id = remote_key_id.get().to_ne_bytes();
-                                // We attach a monotonically increasing counter value to the challenge
-                                // so it cannot be replayed.
-                                let counter = self.0.challenge_counter.fetch_add(1, Ordering::Relaxed);
-                                challenge.challenge_counter = counter.to_be_bytes();
-
-                                hasher.0.reset();
-                                hasher.0.update(&counter.to_be_bytes());
-                                remote_address.hash(&mut hasher);
-                                hasher.0.update(&self.0.challenge_salt);
-                                hasher.0.finish(&mut output);
-                                challenge.challenge_mac.copy_from_slice(&output[..CHALLENGE_MAC_SIZE]);
-                                challenge.prior_challenge_pow = response.challenge_pow;
-                                // We haven't decrypted any of Alice's packet so we don't know the
-                                // header protection cipher.
-                                // For DOS resistance Alice will not accept unencrypted headers directly
-                                // into their session defrag buffer, so we have to send them this reply
-                                // through their incoming sessions cache.
-                                send_with_fragmentation(
-                                    &mut send_unassociated_reply,
-                                    send_unassociated_mtu,
-                                    &mut challenge_buffer,
-                                    PACKET_TYPE_BOB_DOS_CHALLENGE,
-                                    None,
-                                    self.0.rng.lock().unwrap().next_u64(),
-                                    None::<&Application::PrpEnc>,
-                                );
-                                return Ok(ReceiveResult::Unassociated);
-                            }
-                            // Alice succeeded at the challenge so continue to decryption.
-                        }
-                        IncomingSessionAction::Drop => return Ok(ReceiveResult::Rejected),
-                    }
-
-                    // Noise process handshake prologue.
-                    let noise_h = mix_hash(
-                        sha512,
-                        &INITIAL_H,
-                        &message[NoiseXKPattern1::PROLOGUE_START..NoiseXKPattern1::PROLOGUE_END],
-                    );
-                    let noise_h = mix_hash(sha512, &noise_h, self.0.static_keypair.public_key_bytes());
-                    // Noise process pattern1 e token.
-                    let mut noise_ck = SymmetricState::new(INITIAL_H);
-                    let hmac = &mut Application::HmacHash::new();
-                    let mut noise_es = Secret::new();
-                    let noise_e_pattern1 = from_bytes_agreement::<Application>(&noise_pattern1.noise_e, &self.0.static_keypair, noise_es.as_mut())
-                        .ok_or(byzantine_fault!(FaultType::FailedAuthentication, false))?;
-                    let noise_h_e = mix_hash(sha512, &noise_h, &noise_pattern1.noise_e);
-                    noise_ck.mix_key(hmac, &noise_pattern1.noise_e);
-                    // Noise process pattern1 es token.
-                    let noise_k_es = noise_ck.mix_key_initialize_key(hmac, noise_es.as_ref());
-                    drop(noise_es);
-                    // Noise process pattern1 e1 token.
-                    let (is_auth, noise_h_ee1) = decrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_es,
-                        &noise_h_e,
-                        packet_type,
-                        0,
-                        &mut message[NoiseXKPattern1::E1_ENC_START..NoiseXKPattern1::P_ENC_START],
-                    );
-                    if !is_auth {
-                        // This could occur naturally if Alice's ApplicationLayer is dynamically
-                        // changing their mtu, which in bad network conditions could clobber their
-                        // resent KEX packet.
-                        // Or maybe Alice randomly generated the same temporary id twice in a row.
-                        // Since these situations are super unlikely to occur we still mark this error
-                        // as unnatural.
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    }
-                    // Noise process pattern1 payload.
-                    let (is_auth, noise_h_ee1p) = decrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_es,
-                        &noise_h_ee1,
-                        packet_type,
-                        1,
-                        &mut message[NoiseXKPattern1::P_ENC_START..p_auth_end],
-                    );
-                    drop(noise_k_es);
-                    if !is_auth {
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    }
-                    let (header_b2a_key, header_a2b_key) = noise_ck.get_ask2(hmac, LABEL_HEADER_KEY, &noise_h_ee1p);
-                    // Get ratchet key.
-                    let noise_pattern1: &NoiseXKPattern1 = byte_array_as_proto_buffer(message);
-                    let mut ratchet_state = RatchetState::Null;
-                    for i in 0..total_ratchet_fingerprints {
-                        match app.restore_by_fingerprint(
-                            (&noise_pattern1.payload[i * RATCHET_SIZE..(i + 1) * RATCHET_SIZE]).try_into().unwrap(),
-                            current_time,
-                        ) {
-                            Ok(RatchetState::Null) | Ok(RatchetState::Empty) => {}
-                            Ok(rs) => {
-                                ratchet_state = rs;
-                                break;
-                            }
-                            Err(e) => return Err(ReceiveError::RatchetIoError(e)),
-                        }
-                    }
-                    if ratchet_state.is_null() {
-                        if app.hello_requires_recognized_ratchet(current_time) {
-                            return Ok(ReceiveResult::Rejected);
-                        }
-                        ratchet_state = RatchetState::Empty;
-                    }
-
-                    // Start of Noise XKhfs+psk2 pattern2.
-                    let mut message2 = [0u8; NoiseXKPattern2::SIZE];
-                    let noise_pattern2: &mut NoiseXKPattern2 = byte_array_as_proto_buffer_mut(&mut message2);
-                    // Noise process pattern2 e token.
-                    let noise_e_pattern2_secret = Application::KeyPair::generate(&mut self.0.rng.lock().unwrap());
-                    noise_pattern2.noise_e = *noise_e_pattern2_secret.public_key_bytes();
-                    let noise_h_ee1pe = mix_hash(sha512, &noise_h_ee1p, &noise_pattern2.noise_e);
-                    noise_ck.mix_key(hmac, &noise_pattern2.noise_e);
-                    // Noise process pattern2 ee token.
-                    let mut noise_ee = Secret::new();
-                    if !noise_e_pattern2_secret.agree(&noise_e_pattern1, noise_ee.as_mut()) {
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    }
-                    let noise_k_esee = noise_ck.mix_key_initialize_key(hmac, noise_ee.as_ref());
-                    drop(noise_ee);
-                    // Noise process pattern2 ekem1 token.
-                    let (noise_ekem1, noise_ekem1_secret) = pqc_kyber::encapsulate(&noise_pattern1.noise_e1, self.0.rng.lock().unwrap().deref_mut())
-                        .map_err(|_| byzantine_fault!(FaultType::FailedAuthentication, false))
-                        .map(|(ct, ekem1)| (ct, Secret(ekem1)))?;
-                    // Alice fully authenticated.
-                    noise_pattern2.noise_ekem1 = noise_ekem1;
-                    let noise_h_ee1peekem1 = encrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_esee,
-                        &noise_h_ee1pe,
-                        PACKET_TYPE_NOISE_XK_PATTERN_2,
-                        0,
-                        &mut message2[NoiseXKPattern2::EKEM1_ENC_START..NoiseXKPattern2::P_ENC_START],
-                    );
-                    drop(noise_k_esee);
-                    noise_ck.mix_key(hmac, noise_ekem1_secret.as_ref());
-                    drop(noise_ekem1_secret);
-                    // Noise process pattern2 psk token.
-                    let ratchet_key = ratchet_state.key().unwrap();
-                    let (temp_h, noise_k_eseeekem1psk) = noise_ck.mix_key_and_hash_initialize_key(hmac, ratchet_key);
-                    let noise_h_ee1peekem1psk = mix_hash(sha512, &noise_h_ee1peekem1, &temp_h);
-                    // Noise process pattern2 payload.
-                    // We try to prevent the id we generate from colliding with another session but
-                    // because we might have handshakes in flight it's impossible to 100% prevent.
-                    // In those exceedingly rare cases we have to drop Alice's session and start over.
-                    let local_key_id = generate_key_id(&self.0.session_map.read().unwrap(), &mut self.0.rng.lock().unwrap());
-                    let noise_pattern2: &mut NoiseXKPattern2 = byte_array_as_proto_buffer_mut(&mut message2);
-                    noise_pattern2.bob_key_id = local_key_id.get().to_ne_bytes();
-
-                    let noise_h_ee1peekem1pskp = encrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_eseeekem1psk,
-                        &noise_h_ee1peekem1psk,
-                        PACKET_TYPE_NOISE_XK_PATTERN_2,
-                        0,
-                        &mut message2[NoiseXKPattern2::P_ENC_START..NoiseXKPattern2::P_AUTH_END],
-                    );
-
-                    app.event_log(LogEvent::ReceiveValidXK1, current_time);
-                    let handshake = Arc::new(NoiseXKBobHandshakeState {
-                        local_key_id,
-                        remote_key_id,
-                        ratchet_state,
-                        noise_h_ee1peekem1pskp,
-                        noise_ck_eseeekem1psk: noise_ck.clone(),
-                        noise_k_eseeekem1psk: noise_k_eseeekem1psk.clone(),
-                        noise_e_secret: noise_e_pattern2_secret,
-                        header_receive_key: header_a2b_key.clone(),
-                        header_send_key: header_b2a_key.clone(),
-                        noise_pattern3_defrag: Mutex::new(Fragged::new()),
-                    });
-                    self.0.unassociated_handshake_states.insert(local_key_id, handshake, current_time);
-
-                    // We put a copy of the gcm tag in the header so Alice can tell this packet apart
-                    // from any other pattern 1 packet we send, without having to make Bob maintain state.
-                    let mut pattern2_id = 0u64.to_ne_bytes();
-                    pattern2_id[5] = message2[NoiseXKPattern2::P_AUTH_END - 3];
-                    pattern2_id[6] = message2[NoiseXKPattern2::P_AUTH_END - 2];
-                    pattern2_id[7] = message2[NoiseXKPattern2::P_AUTH_END - 1];
-                    send_with_fragmentation(
-                        &mut send_unassociated_reply,
-                        send_unassociated_mtu,
-                        &mut message2,
-                        PACKET_TYPE_NOISE_XK_PATTERN_2,
-                        Some(remote_key_id),
-                        u64::from_be_bytes(pattern2_id),
-                        Some(&Application::PrpEnc::new(header_b2a_key.first_n::<AES_GCM_KEY_SIZE>())),
-                    );
-
-                    return Ok(ReceiveResult::Unassociated);
-                } else {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-            }
-            PACKET_TYPE_BOB_DOS_CHALLENGE => {
-                let message = &mut message[..message_size];
-                app.event_log(LogEvent::ReceiveUncheckedDOSChallenge, current_time);
-
-                // We expect Bob to only send this to us through our unassociated defrag cache.
-                if incoming.is_some() || session.is_some() {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-                if message.len() != BobDOSChallenge::SIZE {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                let challenge: &BobDOSChallenge = byte_array_as_proto_buffer(message);
-
-                if let Some(local_key_id) = NonZeroU32::new(u32::from_ne_bytes(challenge.alice_key_id)) {
-                    if let Some(session) = self.0.session_map.read().unwrap().get(&local_key_id).and_then(|s| s.0.upgrade()) {
-                        // We don't need to hold the kex lock because we are not transitioning state.
-                        let mut state = session.state.write().unwrap();
-                        if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
-                            if let NoiseXKAliceHandshakeState::NoiseXKPattern1 { noise_message, noise_message_len, .. } = &mut handshake_state.offer {
-                                let response_raw = &mut noise_message[*noise_message_len - ChallengeResponse::SIZE..];
-
-                                let response: &mut ChallengeResponse = byte_array_as_proto_buffer_mut(response_raw);
-                                // Only people who know what Alice's prior pow was can convince us to
-                                // compute a new pow.
-                                if challenge.prior_challenge_pow != response.challenge_pow {
-                                    // This can occur if Bob sends us multiple challenges and they
-                                    // arrive OOO.
-                                    return Err(byzantine_fault!(FaultType::FailedAuthentication, true));
-                                }
-                                response.challenge_counter.copy_from_slice(&challenge.challenge_counter);
-                                response.challenge_mac.copy_from_slice(&challenge.challenge_mac);
-                                let mut pow = self.0.rng.lock().unwrap().next_u64();
-                                let sha512 = &mut Application::Hash::new();
-                                loop {
-                                    let response: &mut ChallengeResponse = byte_array_as_proto_buffer_mut(response_raw);
-                                    response.challenge_pow.copy_from_slice(&pow.to_be_bytes());
-                                    if verify_pow::<Application>(sha512, response_raw) {
-                                        break;
-                                    }
-                                    pow = pow.wrapping_add(1);
-                                }
-
-                                app.event_log(LogEvent::ReceiveValidDOSChallenge(&session), current_time);
-                                return Ok(ReceiveResult::Unassociated);
-                            } else {
-                                // This could happen if Bob challenges Alice, but their challenge packet
-                                // gets massively delayed.
-                                return Err(byzantine_fault!(FaultType::OutOfSequence, true));
-                            }
-                        } else {
-                            // This could happen if Bob challenges Alice, but their challenge packet
-                            // gets massively delayed.
-                            return Err(byzantine_fault!(FaultType::OutOfSequence, true));
-                        }
-                    } else {
-                        // This can occur naturally if Alice's session was dropped.
-                        return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
-                    }
-                } else {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-            }
-            PACKET_TYPE_NOISE_XK_PATTERN_2 => {
-                // Bob (remote) --> Alice (local)
-                // <- e, ee, ekem1, psk
-                let message = &mut message[..message_size];
-                app.event_log(LogEvent::ReceiveUncheckedXK2, current_time);
-
-                if incoming.is_some() {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-                if message.len() != NoiseXKPattern2::SIZE {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-
-                let session = session.ok_or(byzantine_fault!(FaultType::UnknownLocalKeyId, false))?;
-                let kex_lock = session.state_machine_lock.lock().unwrap();
-                let state = session.state.read().unwrap();
-
-                if let NoiseXKPattern1or3(handshake_state) = &state.outgoing_offer {
-                    if let NoiseXKAliceHandshakeState::NoiseXKPattern1 {
-                        noise_h_ee1p, noise_e_secret, noise_e1_secret, noise_ck_es, ..
-                    } = &handshake_state.offer
-                    {
-                        let noise_pattern2: &NoiseXKPattern2 = byte_array_as_proto_buffer(message);
-                        // Authenticate header counter.
-                        if noise_pattern2.header[13..16] != noise_pattern2.p_gcm_tag[13..16] {
-                            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                        }
-
-                        // Noise process pattern2 e token.
-                        let mut noise_ee = Secret::new();
-                        if let Some(noise_e_pattern2) =
-                            from_bytes_agreement::<Application>(&noise_pattern2.noise_e, noise_e_secret, noise_ee.as_mut())
-                        {
-                            let sha512 = &mut Application::Hash::new();
-                            let hmac = &mut Application::HmacHash::new();
-                            let mut noise_ck = noise_ck_es.clone();
-                            let noise_h_ee1pe = mix_hash(sha512, noise_h_ee1p, noise_e_pattern2.as_bytes());
-                            noise_ck.mix_key(hmac, noise_e_pattern2.as_bytes());
-                            // Noise process pattern2 ee token.
-                            let noise_k_esee = noise_ck.mix_key_initialize_key(hmac, noise_ee.as_ref());
-                            drop(noise_ee);
-                            // Noise process pattern2 ekem1 token.
-                            let (is_auth, noise_h_ee1peekem1) = decrypt_and_hash::<Application>(
-                                sha512,
-                                &noise_k_esee,
-                                &noise_h_ee1pe,
-                                packet_type,
-                                0,
-                                &mut message[NoiseXKPattern2::EKEM1_ENC_START..NoiseXKPattern2::P_ENC_START],
-                            );
-                            let noise_pattern2: &NoiseXKPattern2 = byte_array_as_proto_buffer(message);
-                            let noise_ekem1_secret = pqc_kyber::decapsulate(&noise_pattern2.noise_ekem1, noise_e1_secret.as_ref()).map(Secret);
-                            if let Some(Ok(noise_ekem1_secret)) = is_auth.then_some(noise_ekem1_secret) {
-                                noise_ck.mix_key(hmac, noise_ekem1_secret.as_ref());
-                                drop(noise_ekem1_secret);
-
-                                // We attempt to decrypt the payload at most three times. First two times with
-                                // the ratchet key Alice remembers, and final time with a ratchet
-                                // key of zero if Alice allows ratchet downgrades.
-                                // The following code is not constant time, meaning we leak to an
-                                // attacker whether or not we downgraded.
-                                // We don't currently consider this sensitive enough information to hide.
-                                let mut test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState, Secret<AES_GCM_KEY_SIZE>, [u8; 64])> {
-                                    // Check for which ratchet key Bob wants to use.
-                                    let mut noise_ck = noise_ck.clone();
-                                    let mut payload = [0u8; NoiseXKPattern2::P_AUTH_END - NoiseXKPattern2::P_ENC_START];
-                                    payload.copy_from_slice(&message[NoiseXKPattern2::P_ENC_START..NoiseXKPattern2::P_AUTH_END]);
-                                    // Noise process pattern2 psk token.
-                                    let (temp_h, noise_k_eseeekem1psk) = noise_ck.mix_key_and_hash_initialize_key(hmac, ratchet_key);
-                                    let noise_h_ee1peekem1psk = mix_hash(sha512, &noise_h_ee1peekem1, &temp_h);
-                                    // Noise process pattern2 payload.
-                                    let (is_auth, noise_h_ee1peekem1pskp) = decrypt_and_hash::<Application>(
-                                        sha512,
-                                        &noise_k_eseeekem1psk,
-                                        &noise_h_ee1peekem1psk,
-                                        packet_type,
-                                        0,
-                                        &mut payload,
-                                    );
-                                    if is_auth {
-                                        let key_id = NonZeroU32::new(u32::from_ne_bytes(
-                                            (&payload[..NoiseXKPattern2::P_AUTH_START - NoiseXKPattern2::P_ENC_START])
-                                                .try_into()
-                                                .unwrap(),
-                                        ));
-                                        key_id.map(|kid| (kid, noise_ck, noise_k_eseeekem1psk, noise_h_ee1peekem1pskp))
-                                    } else {
-                                        None
-                                    }
-                                };
-                                // Check first key.
-                                let mut ratchet_i = 0;
-                                let mut result = None;
-                                let mut chain_len = 0;
-                                if let Some(key) = state.ratchet_states[0].key() {
-                                    chain_len = state.ratchet_states[0].chain_len();
-                                    result = test_ratchet_key(key);
-                                }
-                                // Check second key.
-                                if result.is_none() {
-                                    ratchet_i = 1;
-                                    if let Some(key) = state.ratchet_states[1].key() {
-                                        chain_len = state.ratchet_states[1].chain_len();
-                                        result = test_ratchet_key(key);
-                                    }
-                                }
-                                // Check zero key.
-                                if result.is_none() && !app.initiator_disallows_downgrade(&session, current_time) {
-                                    chain_len = 0;
-                                    result = test_ratchet_key(&[0u8; RATCHET_SIZE]);
-                                    if result.is_some() {
-                                        // TODO: add some kind of warning callback or signal.
-                                    }
-                                }
-
-                                if let Some((remote_key_id, mut noise_ck, noise_k_eseeekem1psk, noise_h_ee1peekem1pskp)) = result {
-                                    // Start of Noise XKhfs+psk2 pattern3.
-                                    let mut message3 = [0u8; NoiseXKPattern3::MAX_SIZE];
-                                    // Noise process pattern3 s token.
-                                    let mut noise_se = Secret::new();
-                                    if self.0.static_keypair.agree(&noise_e_pattern2, noise_se.as_mut()) {
-                                        let payload = handshake_state.alice_identity_blob.as_ref();
-                                        // Packet fully authenticated.
-                                        let s_enc_start = HEADER_SIZE;
-                                        let s_auth_start = s_enc_start + P384_PUBLIC_KEY_SIZE;
-                                        let p_enc_start = s_auth_start + AES_GCM_TAG_SIZE;
-                                        let p_auth_start = p_enc_start + payload.len();
-                                        let p_auth_end = p_auth_start + AES_GCM_TAG_SIZE;
-                                        let message3_len = p_auth_end;
-
-                                        message3[s_enc_start..s_auth_start].copy_from_slice(self.0.static_keypair.public_key_bytes());
-                                        let noise_h_ee1peekem1pskps = encrypt_and_hash::<Application>(
-                                            sha512,
-                                            &noise_k_eseeekem1psk,
-                                            &noise_h_ee1peekem1pskp,
-                                            PACKET_TYPE_NOISE_XK_PATTERN_3,
-                                            1,
-                                            &mut message3[s_enc_start..p_enc_start],
-                                        );
-                                        drop(noise_k_eseeekem1psk);
-                                        // Noise process pattern3 se token.
-                                        let noise_k_eseeekem1pskse = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
-                                        drop(noise_se);
-                                        // Noise process pattern3 payload token.
-                                        message3[p_enc_start..p_auth_start].copy_from_slice(payload);
-                                        let noise_h_ee1peekem1pskpsp = encrypt_and_hash::<Application>(
-                                            sha512,
-                                            &noise_k_eseeekem1pskse,
-                                            &noise_h_ee1peekem1pskps,
-                                            PACKET_TYPE_NOISE_XK_PATTERN_3,
-                                            0,
-                                            &mut message3[p_enc_start..p_auth_end],
-                                        );
-                                        drop(noise_k_eseeekem1pskse);
-                                        // Alice finished Noise XKhfs+psk2 handshake.
-                                        // Transition offer state machine to the NoiseXKPattern3 state.
-                                        let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_ee1peekem1pskpsp);
-                                        let new_ratchet_state = RatchetState::new_nonempty(rk, rf, NonZeroU64::new(chain_len + 1).unwrap());
-
-                                        let ratchet_to_preserve = &state.ratchet_states[ratchet_i];
-                                        let result = app.save_ratchet_state(
-                                            &session.remote_static_key,
-                                            &session.application_data,
-                                            [&state.ratchet_states[0], &state.ratchet_states[1]],
-                                            [&new_ratchet_state, ratchet_to_preserve],
-                                            current_time,
-                                        );
-                                        if let Err(e) = result {
-                                            return Err(ReceiveError::RatchetIoError(e));
-                                        }
-
-                                        let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_ee1peekem1pskpsp);
-
-                                        let local_key_id = handshake_state.local_key_id;
-                                        drop(state);
-                                        let mut state = session.state.write().unwrap();
-                                        session
-                                            .kex_send_cipher
-                                            .lock()
-                                            .unwrap()
-                                            .replace(Application::AeadEnc::new(kex_key_a2b.as_ref()));
-                                        session
-                                            .kex_receive_cipher
-                                            .lock()
-                                            .unwrap()
-                                            .replace(Application::AeadDec::new(kex_key_b2a.as_ref()));
-                                        state.ratchet_states[1] = state.ratchet_states[ratchet_i].clone();
-                                        state.ratchet_states[0] = new_ratchet_state;
-
-                                        state.cipher_states[0].replace(SessionKey::new(
-                                            hmac,
-                                            noise_ck,
-                                            local_key_id,
-                                            remote_key_id,
-                                            INIT_COUNTER,
-                                            false,
-                                        ));
-                                        debug_assert!(state.cipher_states[1].is_none());
-                                        if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
-                                            handshake_state.next_retry_time =
-                                                AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS));
-                                            handshake_state.timeout = current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS);
-                                            handshake_state.offer = NoiseXKAliceHandshakeState::NoiseXKPattern3 {
-                                                noise_message: message3,
-                                                noise_message_len: p_auth_end,
-                                            };
-                                        }
-                                        drop(state);
-                                        drop(kex_lock);
-
-                                        if let Some((mut send, mut mtu)) = send_to(&session) {
-                                            mtu = mtu.max(MIN_TRANSPORT_MTU);
-                                            send_with_fragmentation(
-                                                &mut send,
-                                                mtu,
-                                                &mut message3[..message3_len],
-                                                PACKET_TYPE_NOISE_XK_PATTERN_3,
-                                                Some(remote_key_id),
-                                                0,
-                                                Some(&session.header_send_cipher),
-                                            );
-                                        }
-                                        app.event_log(LogEvent::ReceiveValidXK2(&session), current_time);
-                                        return Ok(ReceiveResult::Session(session, SessionEvent::Control));
-                                    }
-                                }
-                            }
-                        }
-                        // Bob failed authentication so we must restart our offer according to Noise.
-                        // We restart the offer instead of dropping the session to defend against DOS.
-                        drop(state);
-                        let mut state = session.state.write().unwrap();
-                        let ratchet_state = state.ratchet_states.clone();
-                        if let NoiseXKPattern1or3(handshake_state) = &mut state.outgoing_offer {
-                            if !handshake_state.reinitialize(
-                                &session,
-                                &ratchet_state,
-                                &mut self.0.session_map.write().unwrap(),
-                                &mut self.0.rng.lock().unwrap(),
-                                current_time,
-                            ) {
-                                session.expire()
-                            }
-                        }
-                        drop(state);
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    } else {
-                        return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                    }
-                } else {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-            }
-            PACKET_TYPE_NOISE_XK_PATTERN_3 => {
-                // Alice (remote) --> Bob (local)
-                // -> s, se
-                let message = &mut message[..message_size];
-                app.event_log(LogEvent::ReceiveUncheckedXK3, current_time);
-
-                if session.is_some() {
-                    return Err(byzantine_fault!(FaultType::OutOfSequence, false));
-                }
-                if message.len() < NoiseXKPattern3::MIN_SIZE || message.len() > NoiseXKPattern3::MAX_SIZE {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                // The code above guarantees to us that each `incoming` handshake state that reaches
-                // this point will be strictly unique, even for the same remote peer.
-                // This property is strictly necessary to prevent catastrophic nonce reuse due to
-                // two session being created with the same set of keys.
-                let handshake_state = incoming.ok_or(byzantine_fault!(FaultType::UnknownLocalKeyId, false))?;
-                let s_enc_start = HEADER_SIZE;
-
-                let s_auth_start = s_enc_start + P384_PUBLIC_KEY_SIZE;
-                let p_enc_start = s_auth_start + AES_GCM_TAG_SIZE;
-                let p_auth_end = message.len();
-                let p_auth_start = p_auth_end - AES_GCM_TAG_SIZE;
-
-                if !(p_enc_start <= p_auth_start) {
-                    return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-                }
-                // Do not read from the message before this point, otherwise an array out of bounds
-                // error is possible.
-                // Noise process pattern3 s token.
-                let sha512 = &mut Application::Hash::new();
-                let hmac = &mut Application::HmacHash::new();
-                let (is_auth, noise_h_ee1peekem1pskps) = decrypt_and_hash::<Application>(
-                    sha512,
-                    &handshake_state.noise_k_eseeekem1psk,
-                    &handshake_state.noise_h_ee1peekem1pskp,
-                    packet_type,
-                    1,
-                    &mut message[s_enc_start..p_enc_start],
-                );
-                if !is_auth {
-                    return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                }
-                // Noise process pattern3 se token.
-                let mut noise_se = Secret::new();
-                if let Some(remote_s_public_key) =
-                    from_bytes_agreement::<Application>(&message[s_enc_start..s_auth_start], &handshake_state.noise_e_secret, noise_se.as_mut())
-                {
-                    let mut noise_ck = handshake_state.noise_ck_eseeekem1psk.clone();
-                    let noise_k_eseeekem1pskse = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
-                    drop(noise_se);
-                    // Noise process pattern3 payload.
-                    let (is_auth, noise_h_ee1peekem1pskpsp) = decrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_eseeekem1pskse,
-                        &noise_h_ee1peekem1pskps,
-                        packet_type,
-                        0,
-                        &mut message[p_enc_start..p_auth_end],
-                    );
-                    drop(noise_k_eseeekem1pskse);
-                    if !is_auth {
-                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                    }
-                    // Bob finished Noise XKhfs+psk2 handshake.
-                    let header_send_cipher = Application::PrpEnc::new(handshake_state.header_send_key.as_ref());
-                    let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_ee1peekem1pskpsp);
-                    let mut send_reject = || {
-                        // We just used a counter with this key, but we are not storing
-                        // the fact we used it in memory. This is currently ok because the
-                        // handshake is being dropped, so nonce reuse can't happen.
-                        let (mut fragment, len) = encrypt_control(
-                            &mut Application::AeadEnc::new(kex_key_b2a.as_ref()),
-                            &header_send_cipher,
-                            PACKET_TYPE_SESSION_REJECTED,
-                            INIT_COUNTER,
-                            handshake_state.remote_key_id.get(),
-                            &[],
-                        );
-                        send_unassociated_reply(&mut fragment[..len]);
-                    };
-
-                    let (responder_disallows_downgrade, responder_silently_rejects) = check_accept_session(
-                        &remote_s_public_key,
-                        &message[p_enc_start..p_auth_start],
-                        handshake_state.ratchet_state.chain_len(),
-                    );
-                    if let Some((responder_disallows_downgrade, application_data)) = responder_disallows_downgrade {
-                        let result = app.restore_by_identity(&remote_s_public_key, &application_data, current_time);
-                        match result {
-                            Ok(true_ratchet_states) => {
-                                let mut has_match = false;
-                                for rs in &true_ratchet_states {
-                                    if !rs.is_null() {
-                                        has_match |= &handshake_state.ratchet_state == rs;
-                                    }
-                                }
-                                if !has_match {
-                                    if !responder_disallows_downgrade && handshake_state.ratchet_state.is_empty() {
-                                        // TODO: add some kind of warning callback or signal.
-                                    } else {
-                                        if !responder_silently_rejects {
-                                            send_reject();
-                                        }
-                                        return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                                    }
-                                }
-
-                                let mut noise_kk_ss = Secret::new();
-                                if !self.0.static_keypair.agree(&remote_s_public_key, noise_kk_ss.as_mut()) {
-                                    return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                                }
-                                let noise_kk_local_init_h = mix_hash(sha512, &INITIAL_H_REKEY, self.0.static_keypair.public_key_bytes());
-                                let noise_kk_local_init_h = mix_hash(sha512, &noise_kk_local_init_h, remote_s_public_key.as_bytes());
-                                let noise_kk_remote_init_h = mix_hash(sha512, &INITIAL_H_REKEY, remote_s_public_key.as_bytes());
-                                let noise_kk_remote_init_h = mix_hash(sha512, &noise_kk_remote_init_h, self.0.static_keypair.public_key_bytes());
-
-                                let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_ee1peekem1pskpsp);
-                                // We must make sure the ratchet key is saved before we transition.
-                                let new_ratchet_state =
-                                    RatchetState::new_nonempty(rk, rf, NonZeroU64::new(handshake_state.ratchet_state.chain_len() + 1).unwrap());
-                                let result = app.save_ratchet_state(
-                                    &remote_s_public_key,
-                                    &application_data,
-                                    [&true_ratchet_states[0], &true_ratchet_states[1]],
-                                    [&new_ratchet_state, &RatchetState::Null],
-                                    current_time,
-                                );
-                                if let Err(e) = result {
-                                    return Err(ReceiveError::RatchetIoError(e));
-                                }
-
-                                let mut session_queue = self.0.session_queue.lock().unwrap();
-                                let queue_idx = session_queue.reserve_index();
-                                let session = Arc::new(Session {
-                                    context: Arc::downgrade(&self.0),
-                                    queue_idx,
-                                    application_data,
-                                    remote_static_key: remote_s_public_key,
-                                    send_counter: AtomicU64::new(INIT_COUNTER),
-                                    session_has_expired: AtomicBool::new(false),
-                                    counter_antireplay_window: std::array::from_fn(|_| AtomicU64::new(0)),
-                                    state_machine_lock: Mutex::new(()),
-                                    state: RwLock::new(SessionMutableState {
-                                        ratchet_states: [new_ratchet_state.clone(), RatchetState::Null],
-                                        cipher_states: [
-                                            Some(SessionKey::new(
-                                                hmac,
-                                                noise_ck,
-                                                handshake_state.local_key_id,
-                                                handshake_state.remote_key_id,
-                                                INIT_COUNTER,
-                                                true,
-                                            )),
-                                            None,
-                                        ],
-                                        current_key: 0,
-                                        outgoing_offer: KeyConfirm {
-                                            next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-                                            timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
-                                        },
-                                    }),
-                                    header_receive_cipher: Application::PrpDec::new(handshake_state.header_receive_key.as_ref()),
-                                    header_send_cipher,
-                                    kex_send_cipher: Mutex::new(Some(Application::AeadEnc::new(kex_key_b2a.as_ref()))),
-                                    kex_receive_cipher: Mutex::new(Some(Application::AeadDec::new(kex_key_a2b.as_ref()))),
-                                    noise_kk_ss,
-                                    noise_kk_local_init_h,
-                                    noise_kk_remote_init_h,
-                                    defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
-                                    was_bob: true,
-                                });
-                                let timer = Reverse(current_time.saturating_add(Application::RETRY_INTERVAL_MS));
-                                session_queue.push_reserved(queue_idx, Arc::downgrade(&session), timer);
-                                drop(session_queue);
-                                // There is the miniscule possibility this key id is already
-                                // in use, in which case we have to drop this session like
-                                // nothing ever happened.
-                                let mut session_map = self.0.session_map.write().unwrap();
-                                if let std::collections::hash_map::Entry::Vacant(e) = session_map.entry(handshake_state.local_key_id) {
-                                    e.insert((Arc::downgrade(&session), false));
-                                    drop(session_map);
-                                    let _ =
-                                        session.send_control(&session.state.read().unwrap(), send_unassociated_reply, PACKET_TYPE_KEY_CONFIRM, &[]);
-
-                                    app.event_log(LogEvent::ReceiveValidXK3(&session.application_data), current_time);
-                                    return Ok(ReceiveResult::Session(session, SessionEvent::NewSession));
-                                } else {
-                                    // This can occur if we accidentally generate a key id collision.
-                                    // There is an extremely short amount of time during which
-                                    // another session can steal this session's id, we'll have to
-                                    // restart the handshake in this case.
-                                    return Err(byzantine_fault!(FaultType::UnknownLocalKeyId, true));
-                                }
-                            }
-                            Err(e) => {
-                                return Err(ReceiveError::RatchetIoError(e));
-                            }
-                        }
-                    } else {
-                        if !responder_silently_rejects {
-                            send_reject();
-                        }
-                        return Ok(ReceiveResult::Rejected);
-                    }
-                } else {
-                    return Err(byzantine_fault!(FaultType::FailedAuthentication, false));
-                }
-            }
-            _ => return Err(byzantine_fault!(FaultType::InvalidPacket, false)),
-        }
-    }
-    /// Helper function for sending the empty string over the session. Useful for keep-alives.
-    ///
-    /// * `session` - The session to send to
-    /// * `send` - Function to call to send physical packet(s); the buffer passed to `send` is a
-    ///   slice of `data`
-    /// * `current_time` - Current time in milliseconds
-    pub fn send_empty(&self, session: &Arc<Session<Application>>, send: impl FnMut(&mut [u8]) -> bool, current_time: i64) -> Result<(), SendError> {
-        self.send(session, send, &mut [0u8; MIN_TRANSPORT_MTU], &[], current_time)
-    }
-    /// Send data over the session.
-    ///
-    /// * `session` - The session to send to
-    /// * `send` - Function to call to send physical packet(s); the buffer passed to `send` is a
-    ///   slice of `data`
-    /// * `mtu_sized_buffer` - A writable work buffer whose size equals the MTU
-    /// * `data` - Data to send
-    /// * `current_time` - Current time in milliseconds
-    pub fn send(
-        &self,
-        session: &Arc<Session<Application>>,
-        mut send: impl FnMut(&mut [u8]) -> bool,
-        mtu_sized_buffer: &mut [u8],
-        mut data: &[u8],
-        current_time: i64,
-    ) -> Result<(), SendError> {
-        if mtu_sized_buffer.len() < MIN_TRANSPORT_MTU {
-            return Err(SendError::InvalidParameter);
-        }
-        let state = session.state.read().unwrap();
-        let key = state.cipher_states[state.current_key].as_ref().ok_or(SendError::SessionNotEstablished)?;
-        let counter = session.get_next_outgoing_counter()?;
-
-        let mut c = key.get_send_cipher(counter)?;
-        c.set_iv(&create_message_nonce(PACKET_TYPE_DATA, counter));
-
-        let fragment_max_chunk_size = mtu_sized_buffer.len() - HEADER_SIZE;
-        let fragment_count = (data.len() + AES_GCM_TAG_SIZE + (fragment_max_chunk_size - 1)) / fragment_max_chunk_size;
-        if fragment_count > MAX_FRAGMENTS {
-            return Err(SendError::DataTooLarge);
-        }
-        let last_fragment_no = fragment_count - 1;
-
-        for fragment_no in 0..fragment_count {
-            let chunk_size = fragment_max_chunk_size.min(data.len());
-            let mut fragment_size = chunk_size + HEADER_SIZE;
-
-            set_packet_header(
-                mtu_sized_buffer,
-                fragment_count as u8,
-                fragment_no as u8,
-                PACKET_TYPE_DATA,
-                key.remote_key_id.get(),
-                counter,
-            );
-
-            c.encrypt(&data[..chunk_size], &mut mtu_sized_buffer[HEADER_SIZE..fragment_size]);
-            data = &data[chunk_size..];
-
-            if fragment_no == last_fragment_no {
-                debug_assert!(data.is_empty());
-                let tagged_fragment_size = fragment_size + AES_GCM_TAG_SIZE;
-                c.finish_encrypt((&mut mtu_sized_buffer[fragment_size..tagged_fragment_size]).try_into().unwrap());
-                fragment_size = tagged_fragment_size;
-            }
-
-            session.header_send_cipher.encrypt_in_place(
-                (&mut mtu_sized_buffer[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END])
-                    .try_into()
-                    .unwrap(),
-            );
-            if !send(&mut mtu_sized_buffer[..fragment_size]) {
-                break;
-            }
-        }
-        drop(c);
-        if counter >= key.rekey_at_counter {
-            if let OfferStateMachine::Normal { .. } = &state.outgoing_offer {
-                drop(state);
-                if let Ok(timer) = initiate_rekey(&self.0, session, send, current_time) {
-                    self.0.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timer));
-                }
-            }
-        }
-        Ok(())
-    }
-    /// Update the challenge window, returning true if the challenge is still valid.
-    fn check_challenge_window(&self, counter: u64) -> bool {
-        let slot = &self.0.challenge_antireplay_window[(counter as usize) % self.0.challenge_antireplay_window.len()];
-        let counter = counter.wrapping_add(1);
-        let prev_counter = slot.load(Ordering::Relaxed);
-        prev_counter < counter
-    }
-    /// Update the challenge window, returning true if the challenge is still valid.
-    fn update_challenge_window(&self, counter: u64) -> bool {
-        let slot = &self.0.challenge_antireplay_window[(counter as usize) % self.0.challenge_antireplay_window.len()];
-        let counter = counter.wrapping_add(1);
-        let prev_counter = slot.fetch_max(counter, Ordering::Relaxed);
-        prev_counter < counter
-    }
-}
-/// Initiate the rekeying protocol. This session will now begin attempting to rekey this session
-/// with its peer, if it was not already.
-fn initiate_rekey<Application: ApplicationLayer>(
-    context: &Arc<ContextInner<Application>>,
-    session: &Arc<Session<Application>>,
-    send: impl FnOnce(&mut [u8]) -> bool,
-    current_time: i64,
-) -> Result<i64, ()> {
-    let mut message = [0u8; NoiseKKPattern1or2::SIZE];
-
-    let kex_lock = session.state_machine_lock.lock().unwrap();
-    let state = session.state.read().unwrap();
-    // We may only attempt to rekey if we are not already doing so.
-    match &state.outgoing_offer {
-        OfferStateMachine::Normal { .. } => (),
-        _ => return Err(()),
-    }
-    let sha512 = &mut Application::Hash::new();
-    let hmac = &mut Application::HmacHash::new();
-    // Start of Noise KKpsk0 pattern1.
-    // Noise process pattern1 psk0 token.
-    let mut noise_ck = SymmetricState::new(INITIAL_H_REKEY);
-    let noise_temp_h = noise_ck.mix_key_and_hash(hmac, state.ratchet_states[0].key().unwrap());
-    let noise_h_psk = mix_hash(sha512, &session.noise_kk_local_init_h, &noise_temp_h);
-    // Noise process pattern1 e token.
-    let noise_e_secret = Application::KeyPair::generate(&mut context.rng.lock().unwrap());
-    let noise_h_pske = mix_hash(sha512, &noise_h_psk, noise_e_secret.public_key_bytes());
-    noise_ck.mix_key(hmac, noise_e_secret.public_key_bytes());
-
-    let noise_pattern1: &mut NoiseKKPattern1or2 = byte_array_as_proto_buffer_mut(&mut message);
-    noise_pattern1.noise_e = *noise_e_secret.public_key_bytes();
-    // Noise process pattern1 es token.
-    let mut noise_es = Secret::new();
-    if !noise_e_secret.agree(&session.remote_static_key, noise_es.as_mut()) {
-        return Err(());
-    }
-    noise_ck.mix_key(hmac, noise_es.as_ref());
-    drop(noise_es);
-    // Noise process pattern1 ss token.
-    let noise_k_pskesss = noise_ck.mix_key_initialize_key(hmac, session.noise_kk_ss.as_ref());
-    // Noise process pattern1 payload token.
-    let mut session_map = context.session_map.write().unwrap();
-    let new_key_id = generate_key_id(&session_map, &mut context.rng.lock().unwrap());
-    let next_key_index = state.current_key ^ 1;
-    session_map.insert(new_key_id, (Arc::downgrade(session), next_key_index > 0));
-    drop(session_map);
-
-    let noise_pattern1: &mut NoiseKKPattern1or2 = byte_array_as_proto_buffer_mut(&mut message);
-    noise_pattern1.key_id = new_key_id.get().to_ne_bytes();
-    let noise_h_pskep = encrypt_and_hash::<Application>(
-        sha512,
-        &noise_k_pskesss,
-        &noise_h_pske,
-        PACKET_TYPE_NOISE_KK_PATTERN_1,
-        0,
-        &mut message[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
-    );
-    drop(noise_k_pskesss);
-
-    drop(state);
-    let mut state = session.state.write().unwrap();
-    state.outgoing_offer = OfferStateMachine::NoiseKKPattern1 {
-        next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-        timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
-        new_key_id,
-        noise_e_secret,
-        noise_message: message.clone(),
-        noise_h_pskep,
-        noise_ck: noise_ck.clone(),
-    };
-    drop(state);
-    drop(kex_lock);
-    let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_NOISE_KK_PATTERN_1, &message);
-    Ok(current_time.saturating_add(Application::RETRY_INTERVAL_MS))
-}
-fn receive_control_fragment<'a, Application: ApplicationLayer, SendFn: FnMut(&mut [u8]) -> bool>(
-    context: &Context<Application>,
-    session: Arc<Session<Application>>,
-    app: &Application,
-    mut send_to: impl FnMut(&Arc<Session<Application>>) -> Option<(SendFn, usize)>,
-    packet_type: u8,
-    counter: u64,
-    fragment: &mut [u8],
-    current_time: i64,
-) -> Result<ReceiveResult<'a, Application>, ReceiveError<Application::StorageError>> {
-    let kex_lock = session.state_machine_lock.lock().unwrap();
-    let state = session.state.read().unwrap();
-    let mut c = session.kex_receive_cipher.lock().unwrap();
-    let message = decrypt_control(
-        c.as_mut().ok_or(byzantine_fault!(FaultType::OutOfSequence, false))?,
-        packet_type,
-        counter,
-        fragment,
-    )?;
-    drop(c);
-    session.update_receive_window(counter);
-    use OfferStateMachine::*;
-    return match packet_type {
-        PACKET_TYPE_SESSION_REJECTED => {
-            if let NoiseXKPattern1or3(_) = &state.outgoing_offer {
-                drop(state);
-                let mut state = session.state.write().unwrap();
-                state.outgoing_offer = OfferStateMachine::Null;
-                drop(state);
-                drop(kex_lock);
-                Ok(ReceiveResult::Session(session, SessionEvent::Rejected))
-            } else {
-                // This can occur naturally because of control packet resends.
-                Err(byzantine_fault!(FaultType::OutOfSequence, true))
-            }
-        }
-        PACKET_TYPE_KEY_CONFIRM => {
-            drop(state);
-            app.event_log(LogEvent::ReceiveValidKeyConfirm(&session), current_time);
-            let mut state = session.state.write().unwrap();
-            // We only want to stop sending NoiseKKPattern2 offers when the latest derived
-            // key is confirmed. And we only want to do that once.
-            let (used_latest_key, try_delete, ret) = match &state.outgoing_offer {
-                NoiseKKPattern2 { .. } => (true, true, SessionEvent::Control),
-                NoiseXKPattern1or3(handshake_state) => {
-                    if let NoiseXKAliceHandshakeState::NoiseXKPattern3 { .. } = &handshake_state.offer {
-                        (true, true, SessionEvent::Established)
-                    } else {
-                        (false, false, SessionEvent::Control)
-                    }
-                }
-                Null => (false, false, SessionEvent::Control),
-                _ => (true, false, SessionEvent::Control),
-            };
-            if try_delete {
-                let result = if !state.ratchet_states[1].is_null() {
-                    app.save_ratchet_state(
-                        &session.remote_static_key,
-                        &session.application_data,
-                        [&state.ratchet_states[0], &state.ratchet_states[1]],
-                        [&state.ratchet_states[0], &RatchetState::Null],
-                        current_time,
-                    )
-                } else {
-                    Ok(())
-                };
-                if let Err(e) = result {
-                    return Err(ReceiveError::RatchetIoError(e));
-                }
-                if let NoiseKKPattern2 { kex_send_key, .. } = &state.outgoing_offer {
-                    session
-                        .kex_send_cipher
-                        .lock()
-                        .unwrap()
-                        .replace(Application::AeadEnc::new(kex_send_key.as_ref()));
-                }
-                state.ratchet_states[1] = RatchetState::Null;
-                state.current_key ^= 1;
-                state.outgoing_offer = new_normal_state(context.0.rng.lock().unwrap().next_u64(), current_time);
-            }
-            drop(state);
-            drop(kex_lock);
-            if used_latest_key {
-                if let Some((send, _)) = send_to(&session) {
-                    let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_ACK, &[]);
-                }
-            }
-            Ok(ReceiveResult::Session(session, ret))
-        }
-        PACKET_TYPE_ACK => {
-            if let KeyConfirm { .. } = &state.outgoing_offer {
-                drop(state);
-                app.event_log(LogEvent::ReceiveValidAck(&session), current_time);
-                let mut state = session.state.write().unwrap();
-                // Check if we should end any current offers and transition back to Normal state
-                state.outgoing_offer = new_normal_state(context.0.rng.lock().unwrap().next_u64(), current_time);
-                drop(kex_lock);
-                drop(state);
-                Ok(ReceiveResult::Session(session, SessionEvent::Control))
-            } else {
-                // This can occur naturally because of control packet resends.
-                Err(byzantine_fault!(FaultType::OutOfSequence, true))
-            }
-        }
-        PACKET_TYPE_NOISE_KK_PATTERN_1 => {
-            app.event_log(LogEvent::ReceiveUncheckedKK1, current_time);
-            let message = &mut message[..NoiseKKPattern1or2::SIZE];
-            let noise_pattern1: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
-            // We need the following operation to be atomic with the change of offer type
-            let (should_rekey_as_bob, chosen_id) = match &state.outgoing_offer {
-                // Check rekey rate limits.
-                Normal { .. } => (true, None),
-                // In the following situation, both parties are in state NoiseKKPattern1,
-                // we need to deterministically allow only one of them to transition to
-                // NoiseKKPattern2.
-                NoiseKKPattern1 { new_key_id, .. } => (session.was_bob, Some(*new_key_id)),
-                _ => (false, None),
-            };
-            if !should_rekey_as_bob {
-                // This can be triggered if both parties attempt rekeying simultaneously, or if the
-                // remote party sent us a duplicate rekey request.
-                // The code above handles this case and only lets one party through to rekeying.
-                drop(state);
-                drop(kex_lock);
-                return Ok(ReceiveResult::Session(session, SessionEvent::Control));
-            }
-            // Noise process pattern1 psk0 token.
-            let sha512 = &mut Application::Hash::new();
-            let hmac = &mut Application::HmacHash::new();
-            let mut noise_ck = SymmetricState::new(INITIAL_H_REKEY);
-            let noise_temp_h = noise_ck.mix_key_and_hash(hmac, state.ratchet_states[0].key().unwrap());
-            let noise_h_psk = mix_hash(sha512, &session.noise_kk_remote_init_h, &noise_temp_h);
-            // Noise process pattern1 e token.
-            // Get public key validation out of the way early
-            let mut noise_es = Secret::new();
-            let mut noise_ee = Secret::new();
-            let mut noise_se = Secret::new();
-            if let Some(alice_e) = from_bytes_agreement::<Application>(&noise_pattern1.noise_e, &context.0.static_keypair, noise_es.as_mut()) {
-                let bob_e_secret = Application::KeyPair::generate(&mut context.0.rng.lock().unwrap());
-                if bob_e_secret.agree(&alice_e, noise_ee.as_mut()) && bob_e_secret.agree(&session.remote_static_key, noise_se.as_mut()) {
-                    let noise_h_pske = mix_hash(sha512, &noise_h_psk, alice_e.as_bytes());
-                    noise_ck.mix_key(hmac, alice_e.as_bytes());
-                    // Noise process pattern1 es token.
-                    noise_ck.mix_key(hmac, noise_es.as_ref());
-                    drop(noise_es);
-                    // Noise process pattern1 ss token.
-                    let noise_k_pskesss = noise_ck.mix_key_initialize_key(hmac, session.noise_kk_ss.as_ref());
-
-                    // Noise process pattern1 payload.
-                    let (is_auth, noise_h_pskep) = decrypt_and_hash::<Application>(
-                        sha512,
-                        &noise_k_pskesss,
-                        &noise_h_pske,
-                        packet_type,
-                        0,
-                        &mut message[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
-                    );
-                    let noise_pattern1: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
-                    if let (true, Some(remote_key_id)) = (is_auth, NonZeroU32::new(u32::from_ne_bytes(noise_pattern1.key_id))) {
-                        // Alice fully authenticated.
-                        // Start of Noise KKpsk0 pattern2.
-                        // Noise process pattern2 e token.
-                        let noise_h_pskepe = mix_hash(sha512, &noise_h_pskep, bob_e_secret.public_key_bytes());
-                        noise_ck.mix_key(hmac, bob_e_secret.public_key_bytes());
-                        // Noise process pattern2 ee token.
-                        noise_ck.mix_key(hmac, noise_ee.as_ref());
-                        drop(noise_ee);
-                        // Noise process pattern2 se token.
-                        let noise_k_pskessseese = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
-                        drop(noise_se);
-                        // Noise process pattern2 payload.
-                        let mut message2 = [0u8; NoiseKKPattern1or2::SIZE];
-                        let noise_pattern2: &mut NoiseKKPattern1or2 = byte_array_as_proto_buffer_mut(&mut message2);
-                        noise_pattern2.noise_e = *bob_e_secret.public_key_bytes();
-                        let mut session_map = context.0.session_map.write().unwrap();
-                        // If we already generated a new key id mapping reuse it.
-                        let new_key_id = chosen_id.unwrap_or_else(|| generate_key_id(&session_map, &mut context.0.rng.lock().unwrap()));
-                        noise_pattern2.key_id = new_key_id.get().to_ne_bytes();
-
-                        let noise_h_pskepep = encrypt_and_hash::<Application>(
-                            sha512,
-                            &noise_k_pskessseese,
-                            &noise_h_pskepe,
-                            PACKET_TYPE_NOISE_KK_PATTERN_2,
-                            0,
-                            &mut message2[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
-                        );
-                        drop(noise_k_pskessseese);
-                        // Bob finished Noise KKpsk0 handshake.
-                        let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_pskepep);
-                        let new_ratchet_state = RatchetState::new_nonempty(rk, rf, NonZeroU64::new(state.ratchet_states[0].chain_len() + 1).unwrap());
-                        let result = app.save_ratchet_state(
-                            &session.remote_static_key,
-                            &session.application_data,
-                            [&state.ratchet_states[0], &state.ratchet_states[1]],
-                            [&new_ratchet_state, &state.ratchet_states[0]],
-                            current_time,
-                        );
-                        if let Err(e) = result {
-                            drop(state);
-                            drop(kex_lock);
-                            return Err(ReceiveError::RatchetIoError(e));
-                        }
-                        let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_pskepep);
-                        // The new "Bob" doesn't know yet if Alice has received the new key, so the
-                        // new key is recorded as the "alt" (key_index ^ 1) but the current key is
-                        // not advanced yet.
-                        let next_key_index = state.current_key ^ 1;
-                        session_map.insert(new_key_id, (Arc::downgrade(&session), next_key_index > 0));
-                        if let Some(pre_id) = state.cipher_states[next_key_index].as_ref().map(|k| k.local_key_id) {
-                            session_map.remove(&pre_id);
-                        }
-                        drop(session_map);
-                        drop(state);
-                        let mut state = session.state.write().unwrap();
-                        let current_counter = session.send_counter.load(Ordering::Relaxed);
-                        session
-                            .kex_receive_cipher
-                            .lock()
-                            .unwrap()
-                            .replace(Application::AeadDec::new(kex_key_a2b.as_ref()));
-                        state.ratchet_states[1] = state.ratchet_states[0].clone();
-                        state.ratchet_states[0] = new_ratchet_state.clone();
-
-                        state.cipher_states[next_key_index].replace(SessionKey::new(
-                            hmac,
-                            noise_ck,
-                            new_key_id,
-                            remote_key_id,
-                            current_counter,
-                            true,
-                        ));
-                        let timer = current_time.saturating_add(Application::RETRY_INTERVAL_MS);
-                        state.outgoing_offer = NoiseKKPattern2 {
-                            next_retry_time: AtomicI64::new(timer),
-                            timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
-                            noise_message: message2,
-                            kex_send_key: kex_key_b2a.clone(),
-                        };
-                        drop(state);
-                        drop(kex_lock);
-                        context.0.session_queue.lock().unwrap().change_priority(session.queue_idx, Reverse(timer));
-
-                        if let Some((send, _)) = send_to(&session) {
-                            let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_NOISE_KK_PATTERN_2, &message2);
-                        }
-                        app.event_log(LogEvent::ReceiveValidKK1(&session), current_time);
-                        return Ok(ReceiveResult::Session(session, SessionEvent::Control));
-                    }
-                }
-            }
-            Err(byzantine_fault!(FaultType::FailedAuthentication, false))
-        }
-        PACKET_TYPE_NOISE_KK_PATTERN_2 => {
-            app.event_log(LogEvent::ReceiveUncheckedKK2, current_time);
-            let message = &mut message[..NoiseKKPattern1or2::SIZE];
-            let noise_pattern2: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
-
-            if let NoiseKKPattern1 { new_key_id, noise_e_secret, noise_ck, noise_h_pskep, .. } = &state.outgoing_offer {
-                // Noise process pattern2 e token.
-                let mut noise_ee = Secret::new();
-                let mut noise_se = Secret::new();
-                if let Some(bob_e) = from_bytes_agreement::<Application>(&noise_pattern2.noise_e, noise_e_secret, noise_ee.as_mut()) {
-                    if context.0.static_keypair.agree(&bob_e, noise_se.as_mut()) {
-                        let sha512 = &mut Application::Hash::new();
-                        let hmac = &mut Application::HmacHash::new();
-                        let mut noise_ck = noise_ck.clone();
-                        let noise_h_pskepe = mix_hash(sha512, noise_h_pskep, bob_e.as_bytes());
-                        noise_ck.mix_key(hmac, bob_e.as_bytes());
-                        // Noise process pattern2 ee token.
-                        noise_ck.mix_key(hmac, noise_ee.as_ref());
-                        drop(noise_ee);
-                        // Noise process pattern2 se token.
-                        let noise_k_pskessseese = noise_ck.mix_key_initialize_key(hmac, noise_se.as_ref());
-                        drop(noise_se);
-                        // Noise process pattern2 payload.
-                        let (is_auth, noise_h_pskepep) = decrypt_and_hash::<Application>(
-                            sha512,
-                            &noise_k_pskessseese,
-                            &noise_h_pskepe,
-                            packet_type,
-                            0,
-                            &mut message[NoiseKKPattern1or2::ENC_START..NoiseKKPattern1or2::AUTH_END],
-                        );
-                        let noise_pattern2: &NoiseKKPattern1or2 = byte_array_as_proto_buffer(message);
-                        if let (true, Some(remote_key_id)) = (is_auth, NonZeroU32::new(u32::from_ne_bytes(noise_pattern2.key_id))) {
-                            // Bob fully authenticated.
-                            // Alice finished Noise KKpsk0 handshake.
-                            let (rk, rf) = noise_ck.get_ask2(hmac, LABEL_RATCHET_STATE, &noise_h_pskepep);
-                            let new_ratchet_state =
-                                RatchetState::new_nonempty(rk, rf, NonZeroU64::new(state.ratchet_states[0].chain_len() + 1).unwrap());
-                            let result = app.save_ratchet_state(
-                                &session.remote_static_key,
-                                &session.application_data,
-                                [&state.ratchet_states[0], &state.ratchet_states[1]],
-                                [&new_ratchet_state, &RatchetState::Null],
-                                current_time,
-                            );
-                            if let Err(e) = result {
-                                drop(state);
-                                drop(kex_lock);
-                                return Err(ReceiveError::RatchetIoError(e));
-                            }
-                            let (kex_key_b2a, kex_key_a2b) = noise_ck.get_ask2(hmac, LABEL_KEX_KEY, &noise_h_pskepep);
-
-                            let new_key_id = *new_key_id;
-                            drop(state);
-                            let mut state = session.state.write().unwrap();
-                            let next_key_index = state.current_key ^ 1;
-                            state.current_key = next_key_index;
-                            if let Some(key) = state.cipher_states[next_key_index].as_ref() {
-                                context.0.session_map.write().unwrap().remove(&key.local_key_id);
-                            }
-                            session
-                                .kex_receive_cipher
-                                .lock()
-                                .unwrap()
-                                .replace(Application::AeadDec::new(kex_key_b2a.as_ref()));
-                            session
-                                .kex_send_cipher
-                                .lock()
-                                .unwrap()
-                                .replace(Application::AeadEnc::new(kex_key_a2b.as_ref()));
-                            state.ratchet_states[1] = RatchetState::Null;
-                            state.ratchet_states[0] = new_ratchet_state.clone();
-
-                            state.cipher_states[next_key_index].replace(SessionKey::new(
-                                hmac,
-                                noise_ck,
-                                new_key_id,
-                                remote_key_id,
-                                session.send_counter.load(Ordering::Relaxed),
-                                false,
-                            ));
-                            state.outgoing_offer = KeyConfirm {
-                                next_retry_time: AtomicI64::new(current_time.saturating_add(Application::RETRY_INTERVAL_MS)),
-                                timeout: current_time.saturating_add(Application::EXPIRATION_TIMEOUT_MS),
-                            };
-                            drop(state);
-                            drop(kex_lock);
-                            // Let Bob know we got the key.
-                            if let Some((send, _)) = send_to(&session) {
-                                let _ = session.send_control(&session.state.read().unwrap(), send, PACKET_TYPE_KEY_CONFIRM, &[]);
-                            }
-                            app.event_log(LogEvent::ReceiveValidKK2(&session), current_time);
-                            return Ok(ReceiveResult::Session(session, SessionEvent::Control));
-                        }
-                    }
-                }
-                // Bob failed authentication so according to Noise we must terminate this
-                // handshake.
-                // This should not happen in practice since this packet will have already passed
-                // authentication under the current key.
-                session.expire();
-                Err(byzantine_fault!(FaultType::FailedAuthentication, false))
-            } else {
-                drop(state);
-                drop(kex_lock);
-                Ok(ReceiveResult::Session(session, SessionEvent::Control))
-            }
-        }
-        _ => Err(byzantine_fault!(FaultType::InvalidPacket, false)),
-    };
-}
-
-impl<Application: ApplicationLayer> Session<Application> {
-    /// This can only fail with `MaxKeyLifetimeExceeded` or `SessionNotEstablished`.
-    fn send_control(
-        &self,
-        state: &SessionMutableState<Application>,
-        send: impl FnOnce(&mut [u8]) -> bool,
-        packet_type: u8,
-        packet: &[u8],
-    ) -> Result<(), SendError> {
-        let key = state.cipher_states[state.current_key].as_ref().ok_or(SendError::SessionNotEstablished)?;
-        let counter = self.get_next_outgoing_counter()?;
-        let mut c = self.kex_send_cipher.lock().unwrap();
-        let (mut fragment, len) = encrypt_control(
-            c.as_mut().ok_or(SendError::SessionNotEstablished)?,
-            &self.header_send_cipher,
-            packet_type,
-            counter,
-            key.remote_key_id.get(),
-            packet,
-        );
-        send(&mut fragment[..len]);
-        Ok(())
-    }
-    /// Check whether this session is established.
-    pub fn established(&self) -> bool {
-        let state = self.state.read().unwrap();
-        !matches!(&state.outgoing_offer, OfferStateMachine::NoiseXKPattern1or3(_) | OfferStateMachine::Null)
-    }
-    /// The static public key of the remote peer.
-    pub fn remote_s_public_key(&self) -> &Application::PublicKey {
-        &self.remote_static_key
-    }
-    /// The current ratchet state of this session.
-    /// The returned values are sensitive and should be securely erased before being dropped.
-    pub fn ratchet_states(&self) -> [RatchetState; 2] {
-        let state = self.state.read().unwrap();
-        state.ratchet_states.clone()
-    }
-    /// The current ratchet count of this session.
-    pub fn ratchet_count(&self) -> u64 {
-        self.state.read().unwrap().ratchet_states[0].chain_len()
-    }
-    /// Mark a session as expired. This will make it impossible for this session to successfully
-    /// receive or send data or control packets. It is recommended to simply `drop` the session
-    /// instead, but this can provide some reassurance in complex shared ownership situations.
-    pub fn expire(&self) {
-        if let Some(context) = self.context.upgrade() {
-            self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
-        }
-    }
-    fn expire_inner(
-        &self,
-        context: &Arc<ContextInner<Application>>,
-        session_queue: &mut IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>,
-    ) {
-        // Prevent this session from being updated.
-        session_queue.remove(self.queue_idx);
-        self.session_has_expired.store(true, Ordering::Relaxed);
-        let _kex_lock = self.state_machine_lock.lock().unwrap();
-        let mut state = self.state.write().unwrap();
-        let mut session_map = context.session_map.write().unwrap();
-        for key in &state.cipher_states {
-            if let Some(pre_id) = key.as_ref().map(|k| k.local_key_id) {
-                session_map.remove(&pre_id);
-            }
-        }
-        use OfferStateMachine::*;
-        match &state.outgoing_offer {
-            NoiseXKPattern1or3(handshake_state) => session_map.remove(&handshake_state.local_key_id),
-            NoiseKKPattern1 { new_key_id, .. } => session_map.remove(new_key_id),
-            _ => None,
-        };
-        state.outgoing_offer = OfferStateMachine::Null;
-    }
-
-    /// Get the next outgoing counter value.
-    fn get_next_outgoing_counter(&self) -> Result<u64, SendError> {
-        if self.session_has_expired.load(Ordering::Relaxed) {
-            Err(SendError::SessionExpired)
-        } else {
-            let counter = self.send_counter.fetch_add(1, Ordering::Relaxed);
-            if counter > THREAD_SAFE_COUNTER_HARD_EXPIRE {
-                // Because this thread sets the flag itself it will never be able to increment the
-                // counter again.
-                // For that reason the other atomic orderings can be `Relaxed`.
-                self.session_has_expired.store(true, Ordering::SeqCst)
-            }
-            Ok(counter)
-        }
-    }
-    /// Check the receive window without mutating state.
-    fn check_receive_window(&self, counter: u64) -> bool {
-        let slot = &self.counter_antireplay_window[(counter as usize) % self.counter_antireplay_window.len()];
-        let counter = counter.wrapping_add(1);
-        let prev_counter = slot.load(Ordering::Relaxed);
-        prev_counter < counter && counter.wrapping_sub(prev_counter) <= COUNTER_WINDOW_MAX_SKIP_AHEAD
-    }
-    /// Update the receive window, returning true if the packet is still valid.
-    /// This should only be called after the packet is authenticated.
-    fn update_receive_window(&self, counter: u64) -> bool {
-        let slot = &self.counter_antireplay_window[(counter as usize) % self.counter_antireplay_window.len()];
-        let counter = counter.wrapping_add(1);
-        let prev_counter = slot.fetch_max(counter, Ordering::Relaxed);
-        prev_counter < counter && counter.wrapping_sub(prev_counter) <= COUNTER_WINDOW_MAX_SKIP_AHEAD
-    }
-}
-impl<Application: ApplicationLayer> Drop for Session<Application> {
-    fn drop(&mut self) {
-        if let Some(context) = self.context.upgrade() {
-            self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
-        }
-    }
-}
-
-impl<Application: ApplicationLayer> NoiseXKAliceHandshake<Application> {
-    /// Can only fail with `OpenError::InvalidPublicKey` because of remote_s_public_key.
-    /// Corresponds to Noise `Initialize`.
-    fn initialize(
-        local_key_id: NonZeroU32,
-        remote_s_public_key: &Application::PublicKey,
-        ratchet_state: &[RatchetState; 2],
-        rng: &mut Application::Rng,
-    ) -> Result<
-        (
-            NoiseXKAliceHandshakeState<Application>,
-            Secret<AES_GCM_KEY_SIZE>,
-            Secret<AES_GCM_KEY_SIZE>,
-        ),
-        OpenError<Application::StorageError>,
-    > {
-        let mut message = [0u8; NoiseXKPattern1::MAX_SIZE];
-        let sha512 = &mut Application::Hash::new();
-        let hmac = &mut Application::HmacHash::new();
-        // Start of Noise XKhfs+psk2 pattern1.
-        let noise_pattern1: &mut NoiseXKPattern1 = byte_array_as_proto_buffer_mut(&mut message);
-        let noise_e_secret = Application::KeyPair::generate(rng);
-        let noise_e1_secret = pqc_kyber::keypair(rng);
-        noise_pattern1.alice_key_id = local_key_id.get().to_ne_bytes();
-        noise_pattern1.noise_e = *noise_e_secret.public_key_bytes();
-        noise_pattern1.noise_e1 = noise_e1_secret.public;
-        // Noise process prologue.
-        let noise_h = mix_hash(
-            sha512,
-            &INITIAL_H,
-            &message[NoiseXKPattern1::PROLOGUE_START..NoiseXKPattern1::PROLOGUE_END],
-        );
-        let noise_h = mix_hash(sha512, &noise_h, remote_s_public_key.as_bytes());
-        // Noise process pattern1 e token.
-        let mut noise_ck = SymmetricState::new(INITIAL_H);
-        let noise_h_e = mix_hash(sha512, &noise_h, noise_e_secret.public_key_bytes());
-        noise_ck.mix_key(hmac, noise_e_secret.public_key_bytes());
-        // Noise process pattern1 es token.
-        let mut noise_es = Secret::new();
-        if !noise_e_secret.agree(remote_s_public_key, noise_es.as_mut()) {
-            return Err(OpenError::InvalidPublicKey);
-        }
-        let noise_k_es = noise_ck.mix_key_initialize_key(hmac, noise_es.as_ref());
-        drop(noise_es);
-        // Noise process pattern1 e1 token.
-        let noise_h_ee1 = encrypt_and_hash::<Application>(
-            sha512,
-            &noise_k_es,
-            &noise_h_e,
-            PACKET_TYPE_NOISE_XK_PATTERN_1,
-            0,
-            &mut message[NoiseXKPattern1::E1_ENC_START..NoiseXKPattern1::P_ENC_START],
-        );
-        // Noise process pattern1 payload.
-        let noise_pattern1: &mut NoiseXKPattern1 = byte_array_as_proto_buffer_mut(&mut message);
-        let mut idx = 0;
-        for rs in ratchet_state {
-            if let Some(rf) = rs.fingerprint() {
-                let next_idx = idx + RATCHET_SIZE;
-                noise_pattern1.payload[idx..next_idx].copy_from_slice(rf);
-                idx = next_idx;
-            }
-        }
-        let p_auth_end = NoiseXKPattern1::P_ENC_START + idx + AES_GCM_TAG_SIZE;
-        let noise_message_len = p_auth_end + ChallengeResponse::SIZE;
-
-        let noise_h_ee1p = encrypt_and_hash::<Application>(
-            sha512,
-            &noise_k_es,
-            &noise_h_ee1,
-            PACKET_TYPE_NOISE_XK_PATTERN_1,
-            1,
-            &mut message[NoiseXKPattern1::P_ENC_START..p_auth_end],
-        );
-        drop(noise_k_es);
-        let (header_b2a_key, header_a2b_key) = noise_ck.get_ask2(hmac, LABEL_HEADER_KEY, &noise_h_ee1p);
-        let message_id = u64::from_be_bytes(message[p_auth_end - 8..p_auth_end].try_into().unwrap());
-
-        message[noise_message_len - CHALLENGE_POW_SIZE..noise_message_len].copy_from_slice(&rng.next_u64().to_ne_bytes());
-        Ok((
-            NoiseXKAliceHandshakeState::NoiseXKPattern1 {
-                noise_h_ee1p,
-                noise_e_secret,
-                noise_e1_secret: Secret(noise_e1_secret.secret),
-                noise_ck_es: noise_ck,
-                noise_message_len,
-                noise_message: message,
-                message_id,
-            },
-            header_a2b_key,
-            header_b2a_key,
-        ))
-    }
-    /// Should not fail unless Bob's public key is adversarial.
-    fn reinitialize(
-        &mut self,
-        session: &Arc<Session<Application>>,
-        ratchet_state: &[RatchetState; 2],
-        session_map: &mut HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>,
-        rng: &mut Application::Rng,
-        current_time: i64,
-    ) -> bool {
-        let local_key_id = generate_key_id(session_map, rng);
-        if let Ok((offer, a2b_header_key, b2a_header_key)) = Self::initialize(local_key_id, &session.remote_static_key, ratchet_state, rng) {
-            self.timeout = current_time.saturating_add(Application::INITIAL_OFFER_TIMEOUT_MS);
-            session_map.remove(&self.local_key_id);
-            session_map.insert(local_key_id, (Arc::downgrade(session), false));
-            self.local_key_id = local_key_id;
-            self.offer = offer;
-            session.header_send_cipher.reset(a2b_header_key.as_ref());
-            session.header_receive_cipher.reset(b2a_header_key.as_ref());
-            true
-        } else {
-            false
-        }
-    }
-}
-
-/// Create the normal state of the offer state machine, with the correct timestamps.
-fn new_normal_state<Application: ApplicationLayer>(rand: u64, current_time: i64) -> OfferStateMachine<Application> {
-    OfferStateMachine::Normal {
-        timeout: current_time
-            .saturating_add(Application::REKEY_AFTER_TIME_MS)
-            .saturating_sub(rand as i64 % Application::REKEY_AFTER_TIME_MAX_JITTER_MS),
-    }
-}
-/// Get a timestamp of when this timer should trigger next, or None if it should trigger now.
-fn process_timer(timer: &AtomicI64, wait_time: i64, current_time: i64) -> Option<i64> {
-    let ts = timer.load(Ordering::Relaxed);
-    if ts <= current_time && timer.fetch_max(ts.saturating_add(wait_time), Ordering::Relaxed) == ts {
-        None
-    } else {
-        Some(ts)
-    }
-}
-
-/// Corresponds to Noise `EncryptAndHash`.
-fn encrypt_and_hash<Application: ApplicationLayer>(
-    sha512: &mut Application::Hash,
-    noise_k: &Secret<AES_GCM_KEY_SIZE>,
-    noise_h: &[u8; HASHLEN],
-    packet_type: u8,
-    noise_k_uses: u64,
-    message: &mut [u8],
-) -> [u8; HASHLEN] {
-    let auth_start = message.len() - AES_GCM_TAG_SIZE;
-    let mut gcm = Application::AeadEnc::new(noise_k.as_ref());
-    // Encrypt and add authentication tag.
-    gcm.set_iv(&create_message_nonce(packet_type, INIT_COUNTER + noise_k_uses));
-    gcm.set_aad(noise_h);
-    if auth_start > 0 {
-        gcm.encrypt_in_place(&mut message[..auth_start]);
-    }
-    gcm.finish_encrypt((&mut message[auth_start..]).try_into().unwrap());
-    mix_hash(sha512, noise_h, message)
-}
-/// Corresponds to Noise `DecryptAndHash`.
-fn decrypt_and_hash<Application: ApplicationLayer>(
-    sha512: &mut Application::Hash,
-    noise_k: &Secret<AES_GCM_KEY_SIZE>,
-    noise_h: &[u8; HASHLEN],
-    packet_type: u8,
-    noise_k_uses: u64,
-    message: &mut [u8],
-) -> (bool, [u8; HASHLEN]) {
-    let auth_start = message.len() - AES_GCM_TAG_SIZE;
-    let noise_h_c = mix_hash(sha512, noise_h, message);
-    let mut gcm = Application::AeadDec::new(noise_k.as_ref());
-    gcm.set_iv(&create_message_nonce(packet_type, INIT_COUNTER + noise_k_uses));
-    gcm.set_aad(noise_h);
-    if auth_start > 0 {
-        gcm.decrypt_in_place(&mut message[..auth_start]);
-    }
-    (gcm.finish_decrypt((&message[auth_start..]).try_into().unwrap()), noise_h_c)
-}
-/// Encrypt a standardized control packet.
-fn encrypt_control(
-    c: &mut impl AesGcmEnc,
-    header_cipher: &impl AesEnc,
-    packet_type: u8,
-    counter: u64,
-    remote_key_id: u32,
-    packet: &[u8],
-) -> ([u8; CONTROL_PACKET_MAX_SIZE], usize) {
-    let mut fragment = [0u8; CONTROL_PACKET_MAX_SIZE];
-    let fragment_len = packet.len() + HEADER_SIZE + AES_GCM_TAG_SIZE;
-
-    c.set_iv(&create_message_nonce(packet_type, counter));
-    if !packet.is_empty() {
-        fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE].copy_from_slice(packet);
-        c.encrypt_in_place(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE]);
-    }
-    c.finish_encrypt((&mut fragment[fragment_len - AES_GCM_TAG_SIZE..fragment_len]).try_into().unwrap());
-    set_packet_header(&mut fragment, 1, 0, packet_type, remote_key_id, counter);
-    header_cipher.encrypt_in_place((&mut fragment[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END]).try_into().unwrap());
-    (fragment, fragment_len)
-}
-fn decrypt_control<'a, IoError>(
-    c: &mut impl AesGcmDec,
-    packet_type: u8,
-    counter: u64,
-    fragment: &'a mut [u8],
-) -> Result<&'a mut [u8], ReceiveError<IoError>> {
-    let fragment_len = fragment.len();
-    if !(CONTROL_PACKET_MIN_SIZE..=CONTROL_PACKET_MAX_SIZE).contains(&fragment_len) {
-        return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-    }
-    c.set_iv(&create_message_nonce(packet_type, counter));
-    c.decrypt_in_place(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE]);
-    if !c.finish_decrypt((&fragment[fragment_len - AES_GCM_TAG_SIZE..fragment_len]).try_into().unwrap()) {
-        // This can occur naturally if one of the remote peers resent a
-        // control packet that got delayed and arrived out of order.
-        return Err(byzantine_fault!(FaultType::FailedAuthentication, true));
-    }
-    Ok(&mut fragment[HEADER_SIZE..fragment_len - AES_GCM_TAG_SIZE])
-}
-
-fn set_packet_header(packet: &mut [u8], fragment_count: u8, fragment_no: u8, packet_type: u8, remote_key_id: u32, counter_or_id: u64) {
-    debug_assert!(packet.len() >= MIN_PACKET_SIZE);
-    debug_assert!(fragment_count > 0);
-    debug_assert!(fragment_count <= MAX_FRAGMENTS as u8);
-    debug_assert!(fragment_no < MAX_FRAGMENTS as u8);
-    debug_assert_eq!((packet_type << 1) >> 1, packet_type);
-    // [0..4]   recipient key id
-    // -- start AES(ck_es * h_e_e1_p) encrypted block --
-    // [4]      fragment count (1..255)
-    // [5]      fragment number (0..254)
-    // [6]      reserved zero
-    // -- start of AES-GCM Nonce --
-    // [7]      packet type
-    // [8..16]  64-bit counter or packet id (big endian)
-    packet[4..16].copy_from_slice(&create_message_nonce(packet_type, counter_or_id));
-    packet[0..4].copy_from_slice(&remote_key_id.to_ne_bytes());
-    packet[4] = fragment_count;
-    packet[5] = fragment_no;
-    packet[6] = 0;
-}
-/// Create a 96-bit AES-GCM nonce.
-///
-/// The primary information that we want to be contained here is the counter and the
-/// packet type. The former makes this unique and the latter's inclusion authenticates
-/// it as effectively AAD. Other elements of the header are either not authenticated,
-/// like fragmentation info, or their authentication is implied via key exchange like
-/// the key id.
-fn create_message_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
-    let mut ret = [0u8; AES_GCM_IV_SIZE];
-    ret[3] = packet_type;
-    // Noise requires a big endian counter at the end of the Nonce
-    ret[4..].copy_from_slice(&counter.to_be_bytes());
-    ret
-}
-/// returns `(fragment_count, fragment_no, packet_type, counter, header_nonce)`.
-fn parse_packet_header(packet: &[u8]) -> (u8, u8, u8, u64, [u8; 10]) {
-    let header_nonce = packet[6..16].try_into().unwrap();
-    let counter = packet[8..16].try_into().unwrap();
-    // We intentionally ignore the version number for future revisions.
-    (packet[4], packet[5], packet[7], u64::from_be_bytes(counter), header_nonce)
-}
-
-/// Break a packet into fragments and send them all.
-///
-/// The contents of packet[] are mangled during this operation, so it should be discarded after.
-/// This is only used for key exchange and control packets. For data packets this is done inline
-/// for better performance with encryption and fragmentation happening at the same time.
-fn send_with_fragmentation(
-    send: &mut impl FnMut(&mut [u8]) -> bool,
-    mtu: usize,
-    packet: &mut [u8],
-    packet_type: u8,
-    remote_key_id: Option<NonZeroU32>,
-    counter_or_id: u64,
-    header_cipher: Option<&impl AesEnc>,
-) -> bool {
-    let packet_len = packet.len();
-    let fragment_count = (packet_len.saturating_add(mtu - 1)) / mtu; // integer ceiling divide
-    debug_assert!(fragment_count <= MAX_FRAGMENTS);
-    let mut fragment_start = 0;
-    let mut fragment_end = packet_len.min(mtu);
-    let mut fragment_no = 0;
-    loop {
-        let fragment = &mut packet[fragment_start..fragment_end];
-        set_packet_header(
-            fragment,
-            fragment_count as u8,
-            fragment_no as u8,
-            packet_type,
-            remote_key_id.map_or(0, |n| n.get()),
-            counter_or_id,
-        );
-        if let Some(hcc) = header_cipher {
-            hcc.encrypt_in_place((&mut fragment[HEADER_PROTECT_ENC_START..HEADER_PROTECT_ENC_END]).try_into().unwrap());
-        }
-        if !send(fragment) {
-            return false;
-        }
-        fragment_no += 1;
-        if fragment_no < fragment_count {
-            fragment_start = fragment_end - HEADER_SIZE;
-            fragment_end = (fragment_start.saturating_add(mtu)).min(packet_len);
-        } else {
-            break;
-        }
-    }
-    true
-}
-
-/// Assemble a series of fragments into a buffer and return the length of the assembled packet in
-/// bytes.
-///
-/// This is also only used for key exchange and control packets. For data packets decryption and
-/// assembly happen in one pass for better performance.
-fn assemble_fragments_into<A: ApplicationLayer>(fragments: &[A::IncomingPacketBuffer], d: &mut [u8]) -> Result<usize, ReceiveError<A::StorageError>> {
-    let mut l = 0;
-    for i in 0..fragments.len() {
-        let mut ff = fragments[i].as_ref();
-        if i > 0 {
-            ff = &ff[HEADER_SIZE..];
-        }
-        let j = l + ff.len();
-        if j > d.len() {
-            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
-        }
-        d[l..j].copy_from_slice(ff);
-        l = j;
-    }
-    Ok(l)
-}
-/// Generate a random local key id that is currently unused.
-fn generate_key_id<Application: ApplicationLayer>(
-    session_map: &HashMap<NonZeroU32, (Weak<Session<Application>>, bool)>,
-    rng: &mut Application::Rng,
-) -> NonZeroU32 {
-    loop {
-        if let Some(local_key_id) = NonZeroU32::new(rng.next_u32()) {
-            if !session_map.contains_key(&local_key_id) {
-                return local_key_id;
-            }
-        }
-    }
-}
-
-impl<Application: ApplicationLayer> SessionKey<Application> {
-    fn new(
-        hmac: &mut Application::HmacHash,
-        ck: SymmetricState,
-        local_key_id: NonZeroU32,
-        remote_key_id: NonZeroU32,
-        current_counter: u64,
-        is_bob: bool,
-    ) -> Self {
-        let (b2a, a2b) = ck.split(hmac);
-        let (receive_key, send_key) = if is_bob {
-            (&a2b, &b2a)
-        } else {
-            (&b2a, &a2b)
-        };
-        let send_cipher_pool = std::array::from_fn(|_| Mutex::new(Application::AeadEnc::new(send_key.as_ref())));
-        let receive_cipher_pool = std::array::from_fn(|_| Mutex::new(Application::AeadDec::new(receive_key.as_ref())));
-        Self {
-            local_key_id,
-            remote_key_id,
-            send_cipher_pool,
-            receive_cipher_pool,
-            rekey_at_counter: current_counter.saturating_add(Application::REKEY_AFTER_USES),
-            expire_at_counter: current_counter.saturating_add(Application::EXPIRE_AFTER_USES),
-        }
-    }
-
-    fn get_send_cipher(&self, counter: u64) -> Result<MutexGuard<Application::AeadEnc>, SendError> {
-        if counter < self.expire_at_counter {
-            Ok(self.send_cipher_pool[(counter as usize) % self.send_cipher_pool.len()].lock().unwrap())
-        } else {
-            Err(SendError::SessionExpired)
-        }
-    }
-
-    fn get_receive_cipher(&self, counter: u64) -> MutexGuard<Application::AeadDec> {
-        let idx = (counter as usize) % self.receive_cipher_pool.len();
-        self.receive_cipher_pool[idx].lock().unwrap()
-    }
-}
-
-/// MixHash to update 'h' during negotiation.
-fn mix_hash(hasher: &mut impl Sha512, h: &[u8; HASHLEN], m: &[u8]) -> [u8; HASHLEN] {
-    let mut output = [0u8; HASHLEN];
-    hasher.reset();
-    hasher.update(h);
-    hasher.update(m);
-    hasher.finish(&mut output);
-    output
-}
-/// Check if the proof of work attached to the first message contains the correct number of leading
-/// zeros.
-fn verify_pow<Application: ApplicationLayer>(hasher: &mut Application::Hash, response: &[u8]) -> bool {
-    if Application::PROOF_OF_WORK_BIT_DIFFICULTY == 0 {
-        return true;
-    }
-    hasher.reset();
-    hasher.update(response);
-    let mut output = [0u8; HASHLEN];
-    hasher.finish(&mut output);
-    let n = u32::from_be_bytes(output[..4].try_into().unwrap());
-    n.leading_zeros() >= Application::PROOF_OF_WORK_BIT_DIFFICULTY
-}
-fn from_bytes_agreement<Application: ApplicationLayer>(
-    public: &[u8],
-    private: &Application::KeyPair,
-    output: &mut [u8; P384_ECDH_SHARED_SECRET_SIZE],
-) -> Option<Application::PublicKey> {
-    Application::PublicKey::from_bytes(public.try_into().unwrap()).and_then(|e| private.agree(&e, output).then_some(e))
-}
diff --git a/src/zssp.rs b/src/zssp.rs
index b0ba9f8..ff7eed5 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -21,11 +21,8 @@ use arrayvec::ArrayVec;
 use zeroize::Zeroizing;
 
 use crate::challenge::ChallengeContext;
-use crate::crypto::aes::{AesDec, AesEnc, AES_256_KEY_SIZE, AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE};
-use crate::crypto::p384::{P384KeyPair, P384PublicKey, P384_ECDH_SHARED_SECRET_SIZE, P384_PUBLIC_KEY_SIZE};
-use crate::crypto::pqc_kyber::KYBER_SECRETKEYBYTES;
-use crate::crypto::rand_core::RngCore;
-use crate::crypto::sha512::{HashSha512, HmacSha512};
+use crate::crypto::*;
+use rand_core::RngCore;
 use crate::zeta::*;
 
 use crate::frag_cache::UnassociatedFragCache;
@@ -36,7 +33,7 @@ use crate::log_event::LogEvent;
 use crate::proto::*;
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError, SessionEvent};
 use crate::symmetric_state::SymmetricState;
-use crate::{applicationlayer::*, ratchet_state::RatchetState};
+use crate::application::*;
 
 /// Macro to turn off logging at compile time.
 macro_rules! log {

From d4c07cd7a3271511f3c54890dd6c98ed807f9d8f Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 09:20:16 -0400
Subject: [PATCH 21/50] reorganized

---
 src/application.rs     |  12 +-
 src/challenge.rs       |   2 +-
 src/handshake_cache.rs |   2 +-
 src/log_event.rs       |   2 +-
 src/result.rs          |   1 +
 src/symmetric_state.rs |   2 +-
 src/zeta.rs            | 412 +++++++++++++++++++++--------------------
 src/zssp.rs            | 124 +++++++------
 8 files changed, 293 insertions(+), 264 deletions(-)

diff --git a/src/application.rs b/src/application.rs
index 0a28af9..705cdad 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -1,9 +1,9 @@
-use std::sync::Arc;
 use rand_core::{CryptoRng, RngCore};
+use std::sync::Arc;
 
 use crate::crypto::*;
-use crate::zeta::Session;
 use crate::ratchet_state::RatchetState;
+use crate::zeta::Session;
 
 pub use crate::proto::RATCHET_SIZE;
 pub use crate::ratchet_state::*;
@@ -156,6 +156,7 @@ pub trait ApplicationLayer: Sized {
     /// should rekey.
     fn time(&self) -> i64;
 
+    fn incoming_session(&self) -> IncomingSessionAction;
     /// This function will be called whenever Alice's initial Hello packet contains the empty ratchet
     /// fingerprint. Brand new peers will always connect to Bob with the empty ratchet, but from
     /// then on they should be using non-empty ratchet states.
@@ -249,6 +250,13 @@ pub trait ApplicationLayer: Sized {
     fn event_log(&self, event: LogEvent<'_, Self>);
 }
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum IncomingSessionAction {
+    Allow,
+    Challenge,
+    Drop,
+}
+
 /// A collection of fields specifying how to complete the key exchange with a specific remote peer,
 /// used by Bob, the responder, at the very last stage of the key exchange.
 ///
diff --git a/src/challenge.rs b/src/challenge.rs
index c63c916..cc4de21 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -9,7 +9,7 @@ use crate::proto::*;
 
 pub struct ChallengeContext {
     counter: AtomicU64,
-    antireplay_window: Window<COUNTER_WINDOW_MAX_OOO, { u64::MAX }>,
+    antireplay_window: Window<CHALLENGE_COUNTER_WINDOW_MAX_OOO, { u64::MAX }>,
     salt: [u8; SALT_SIZE],
 }
 
diff --git a/src/handshake_cache.rs b/src/handshake_cache.rs
index f5cd728..75b4aa4 100644
--- a/src/handshake_cache.rs
+++ b/src/handshake_cache.rs
@@ -11,7 +11,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock};
 
 use crate::zeta::StateB2;
-use crate::{proto::MAX_UNASSOCIATED_HANDSHAKE_STATES, application::ApplicationLayer};
+use crate::{application::ApplicationLayer, proto::MAX_UNASSOCIATED_HANDSHAKE_STATES};
 
 pub(crate) struct UnassociatedHandshakeCache<Application: ApplicationLayer> {
     has_pending: AtomicBool, // Allowed to be falsely positive
diff --git a/src/log_event.rs b/src/log_event.rs
index a160ad9..1cb6522 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -7,7 +7,7 @@
  */
 use std::sync::Arc;
 
-use crate::{zeta::Session, application::ApplicationLayer};
+use crate::{application::ApplicationLayer, zeta::Session};
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
 pub enum LogEvent<'a, Application: ApplicationLayer> {
diff --git a/src/result.rs b/src/result.rs
index 15b023d..f78e035 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -102,6 +102,7 @@ pub enum ReceiveError<StorageError> {
     /// The associated session will no longer function and has to be dropped.
     MaxKeyLifetimeExceeded,
 
+    Rejected,
     /// One of the ratchet saving or lookup functions returned an error, so the packet had to be
     /// dropped.
     StorageError(StorageError),
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index a780b72..7349d63 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -2,9 +2,9 @@ use std::marker::PhantomData;
 
 use zeroize::Zeroizing;
 
+use crate::application::ApplicationLayer;
 use crate::crypto::*;
 use crate::proto::*;
-use crate::application::ApplicationLayer;
 
 pub struct SymmetricState<App: ApplicationLayer> {
     k: Zeroizing<[u8; AES_256_KEY_SIZE]>,
diff --git a/src/zeta.rs b/src/zeta.rs
index 0278fb7..957faeb 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -6,13 +6,12 @@ use std::io::Write;
 use std::num::NonZeroU32;
 use std::ops::{Deref, DerefMut};
 use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
-use std::sync::{Arc, Mutex, RwLock, Weak};
+use std::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockReadGuard, Weak};
 use zeroize::Zeroizing;
 
 use crate::antireplay::Window;
 use crate::application::*;
 use crate::challenge::{gen_null_response, respond_to_challenge_in_place};
-use crate::zssp::{log, ContextInner, SessionQueue};
 use crate::crypto::*;
 use crate::fragged::Fragged;
 use crate::indexed_heap::BinaryHeapIndex;
@@ -20,6 +19,7 @@ use crate::proto::*;
 use crate::ratchet_state::{RatchetState, RatchetStates};
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
 use crate::symmetric_state::SymmetricState;
+use crate::zssp::{log, ContextInner, SessionQueue};
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
 
@@ -175,7 +175,6 @@ pub(crate) struct StateA3 {
     x3: ArrayVec<u8, HEADERED_HANDSHAKE_COMPLETION_MAX_SIZE>,
 }
 
-
 /// Corresponds to the ZKE Automata found in Section 4.1 - Definition 2.
 pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
     Null,
@@ -259,7 +258,12 @@ impl<App: ApplicationLayer> SymmetricState<App> {
             None
         }
     }
-    fn mix_dh_no_init(&mut self, hmac: &mut App::HmacHash, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
+    fn mix_dh_no_init(
+        &mut self,
+        hmac: &mut App::HmacHash,
+        secret: &App::KeyPair,
+        remote: &App::PublicKey,
+    ) -> Option<()> {
         let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
         if secret.agree(&remote, &mut ecdh_secret) {
             self.mix_key_no_init(hmac, ecdh_secret.as_ref());
@@ -362,9 +366,10 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     identity: &[u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
-    let RatchetStates{state1, state2} = app
+    let RatchetStates { state1, state2 } = app
         .restore_by_identity(&s_remote, &session_data)
-        .map_err(|e| OpenError::RatchetIoError(e))?.unwrap_or_default();
+        .map_err(|e| OpenError::RatchetIoError(e))?
+        .unwrap_or_default();
 
     let mut session_queue = ctx.session_queue.lock().unwrap();
     let mut session_map = ctx.session_map.write().unwrap();
@@ -750,12 +755,13 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         let mut nk_send = Zeroizing::new([0u8; HASHLEN]);
         noise.get_ask(hmac, LABEL_KEX_KEY, &mut kek_recv, &mut kek_send);
         noise.split(hmac, &mut nk_recv, &mut nk_send);
+
         let nonce = to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0);
+        set_header(&mut x3, kid_send.get(), &nonce);
 
         drop(state);
         let resend_timer = {
             let mut state = session.state.write().unwrap();
-
             state.key_mut(true).send.kid = Some(kid_send);
             state.key_mut(true).send.replace_kek(&kek_send);
             state.key_mut(true).recv.replace_kek(&kek_recv);
@@ -773,10 +779,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 // This return is unreachable.
                 return Err(byzantine_fault!(FailedAuth, true));
             };
-            state.beta = ZetaAutomata::A3(Box::new(StateA3 {
-                identity: a1.identity.clone(),
-                x3: x3.clone(),
-            }));
+            state.beta = ZetaAutomata::A3(Box::new(StateA3 { identity: a1.identity.clone(), x3: x3.clone() }));
             resend_timer
         };
         drop(kex_lock);
@@ -787,15 +790,40 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
 
         Ok(x3)
     })();
+
     match result {
         Err(ReceiveError::ByzantineFault { .. }) => {
-            process_timers(app, ctx, session, app.time(), true, false, send);
+            let kex_lock = session.state_machine_lock.lock().unwrap();
+            let state = session.state.read().unwrap();
+            timeout_trans(app, ctx, session, kex_lock, state, app.time(), send);
         }
         Ok(ref mut packet) => send(packet, Some(&session.hk_send)),
         _ => {}
     }
     result.map(|_| ())
 }
+fn send_control<App: ApplicationLayer, const CAP: usize>(
+    session: &Arc<Session<App>>,
+    state: &MutableState<App>,
+    packet_type: u8,
+    mut payload: ArrayVec<u8, CAP>,
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
+) -> bool {
+    if let Some((c, _)) = get_counter(session, &state) {
+        if let (Some(kek), Some(kid)) = (state.key_ref(false).send.kek.as_ref(), state.key_ref(false).send.kid) {
+            let nonce = to_nonce(packet_type, c);
+            let tag = App::Aead::encrypt_in_place(kek, &nonce, &[], &mut payload[HEADER_SIZE..]);
+            payload.extend(tag);
+            set_header(&mut payload, kid.get(), &nonce);
+            send(&mut payload, Some(&session.hk_send));
+            true
+        } else {
+            false
+        }
+    } else {
+        false
+    }
+}
 /// Corresponds to Transition Algorithm 4 found in Section 4.3.
 pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     app: &App,
@@ -909,7 +937,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     return Err(ReceiveError::StorageError(e));
                 }
 
-                let (session, current_time) = {
+                let session = {
                     let mut session_map = ctx.session_map.write().unwrap();
                     use std::collections::hash_map::Entry::*;
                     let entry = match session_map.entry(zeta.kid_recv) {
@@ -959,9 +987,13 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     session_queue.push_reserved(queue_idx, Arc::downgrade(&session), Reverse(resend_timer));
                     entry.insert(Arc::downgrade(&session));
 
-                    (session, current_time)
+                    session
                 };
-                process_timers(app, ctx, &session, current_time, false, true, send);
+                let state = session.state.read().unwrap();
+                let mut c1 = ArrayVec::<u8, HEADERED_KEY_CONFIRMATION_SIZE>::new();
+                c1.extend([0u8; HEADER_SIZE]);
+                send_control(&session, &state, PACKET_TYPE_KEY_CONFIRM, c1, send);
+                drop(state);
 
                 Ok(session)
             }
@@ -969,9 +1001,9 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         }
     } else {
         if !responder_silently_rejects {
-            //send(&create_reject(), Some(&zeta.hk_send))
+            send(&mut create_reject(), Some(&App::PrpEnc::new(&zeta.hk_send)))
         }
-        Err(byzantine_fault!(FailedAuth, true))
+        Err(ReceiveError::Rejected)
     }
 }
 /// Corresponds to Transition Algorithm 5 found in Section 4.3.
@@ -1003,12 +1035,8 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(OutOfSequence, false));
     };
 
-    let specified_key = state
-        .key_ref(is_other)
-        .recv
-        .kek
-        .as_ref()
-        .ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let specified_key = state.key_ref(is_other).recv.kek.as_ref();
+    let specified_key = specified_key.ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = c1[..].try_into().unwrap();
     if !App::Aead::decrypt_in_place(specified_key, n, &[], &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
@@ -1060,25 +1088,12 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
         }
     }
 
-    let mut c2 = ArrayVec::<u8, HEADERED_KEY_CONFIRMATION_SIZE>::new();
+    let mut c2 = ArrayVec::<u8, HEADERED_ACKNOWLEDGEMENT_SIZE>::new();
     c2.extend([0u8; HEADER_SIZE]);
-    let (c, _) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
-    let nonce = to_nonce(PACKET_TYPE_ACK, c);
-    let latest_confirmed_key = state
-        .key_ref(false)
-        .send
-        .kek
-        .as_ref()
-        .ok_or(byzantine_fault!(OutOfSequence, true))?;
-    c2.extend(App::Aead::encrypt_in_place(latest_confirmed_key, &nonce, &[], &mut []));
-    let kid_send = state
-        .key_ref(false)
-        .send
-        .kid
-        .ok_or(byzantine_fault!(OutOfSequence, false))?;
-    set_header(&mut c2, kid_send.get(), &nonce);
+    if !send_control(session, &state, PACKET_TYPE_ACK, c2, send) {
+        return Err(byzantine_fault!(OutOfSequence, true));
+    }
 
-    send(&mut c2, Some(&session.hk_send));
     Ok(just_establised)
 }
 /// Corresponds to the trivial Transition Algorithm described for processing C_2 packets found in
@@ -1171,157 +1186,155 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     session.expire();
     Ok(())
 }
+// Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
+fn timeout_trans<App: ApplicationLayer>(
+    app: &App,
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
+    kex_lock: MutexGuard<'_, ()>,
+    state: RwLockReadGuard<'_, MutableState<App>>,
+    current_time: i64,
+    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
+) -> Option<i64> {
+    match &state.beta {
+        ZetaAutomata::Null => None,
+        ZetaAutomata::A1(_) | ZetaAutomata::A3 { .. } => {
+            let identity = match &state.beta {
+                ZetaAutomata::A1(a1) => &a1.identity,
+                ZetaAutomata::A3(a3) => &a3.identity,
+                _ => unreachable!(),
+            };
+            if matches!(&state.beta, ZetaAutomata::A1(_)) {
+                log!(app, TimeoutX1(session));
+            } else {
+                log!(app, TimeoutX3(session));
+            }
+            let new_kid_recv = remap(ctx, session, &state);
+
+            let hash = &mut App::Hash::new();
+            let hmac = &mut App::HmacHash::new();
+            if let Some(a1) = create_a1_state(
+                hash,
+                hmac,
+                &ctx.rng,
+                &session.s_remote,
+                new_kid_recv,
+                &state.ratchet_state1,
+                state.ratchet_state2.as_ref(),
+                identity,
+            ) {
+                let mut hk_recv = Zeroizing::new([0u8; HASHLEN]);
+                let mut hk_send = Zeroizing::new([0u8; HASHLEN]);
+                a1.noise.get_ask(hmac, LABEL_HEADER_KEY, &mut hk_recv, &mut hk_send);
+                let mut x1 = a1.x1.clone();
+
+                drop(state);
+                let resend_timer = {
+                    let mut state = session.state.write().unwrap();
+                    session
+                        .hk_recv
+                        .reset((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap());
+                    session
+                        .hk_send
+                        .reset((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap());
+                    *state.key_mut(true) = DuplexKey::default();
+                    state.key_mut(true).recv.kid = Some(new_kid_recv);
+                    let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                    state.resend_timer = AtomicI64::new(resend_timer);
+                    state.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
+                    state.beta = ZetaAutomata::A1(a1);
+                    resend_timer
+                };
+                drop(kex_lock);
+
+                send(&mut x1, None);
+                Some(resend_timer)
+            } else {
+                None
+            }
+        }
+        ZetaAutomata::S2 => {
+            // Corresponds to Transition Algorithm 6 found in Section 4.3.
+            log!(app, StartedRekeyingSentK1(session));
+            let new_kid_recv = remap(ctx, session, &state);
+            //    -> s
+            //    <- s
+            //    ...
+            //    -> psk, e, es, ss
+            let mut noise = SymmetricState::initialize(PROTOCOL_NAME_NOISE_KK);
+            let hash = &mut App::Hash::new();
+            let hmac = &mut App::HmacHash::new();
+            let mut k1 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
+            k1.extend([0u8; HEADER_SIZE]);
+            // Noise process prologue.
+            noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
+            noise.mix_hash(hash, &session.s_remote.to_bytes());
+            // Process message pattern 1 psk0 token.
+            noise.mix_key_and_hash(hash, hmac, state.ratchet_state1.key.as_ref());
+            // Process message pattern 1 e token.
+            let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut k1);
+            // Process message pattern 1 es token.
+            if noise.mix_dh(hmac, &e_secret, &session.s_remote).is_none() {
+                return None;
+            }
+            // Process message pattern 1 ss token.
+            noise.mix_key(hmac, session.noise_kk_ss.as_ref());
+            // Process message pattern 1 payload.
+            let i = k1.len();
+            k1.extend(new_kid_recv.get().to_be_bytes());
+            let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..]);
+            k1.extend(tag);
+
+            drop(state);
+            let resend_timer = {
+                let mut state = session.state.write().unwrap();
+                state.key_mut(true).recv.kid = Some(new_kid_recv);
+                state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
+                let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                state.resend_timer = AtomicI64::new(resend_timer);
+                state.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
+                resend_timer
+            };
+            drop(kex_lock);
+            let state = session.state.read().unwrap();
+
+            send_control(session, &state, PACKET_TYPE_REKEY_INIT, k1, send);
+            Some(resend_timer)
+        }
+        ZetaAutomata::S1 { .. } => {
+            log!(app, TimeoutKeyConfirm(session));
+            None
+        }
+        ZetaAutomata::R1 { .. } => {
+            log!(app, TimeoutK1(session));
+            None
+        }
+        ZetaAutomata::R2 { .. } => {
+            log!(app, TimeoutK2(session));
+            None
+        }
+    }
+}
 /// Corresponds to the timer rules of the Zeta State Machine found in Section 4.1 - Definition 3.
 pub(crate) fn process_timers<App: ApplicationLayer>(
     app: &App,
     ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     current_time: i64,
-    force_timeout: bool,
-    force_resend: bool,
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Option<i64> {
     let kex_lock = session.state_machine_lock.lock().unwrap();
     let state = session.state.read().unwrap();
-    if force_timeout || state.timeout_timer <= current_time {
+    if state.timeout_timer <= current_time {
         // Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
-        match &state.beta {
-            ZetaAutomata::Null => None,
-            ZetaAutomata::A1(_) | ZetaAutomata::A3 { .. } => {
-                let identity = match &state.beta {
-                    ZetaAutomata::A1(a1) => &a1.identity,
-                    ZetaAutomata::A3(a3) => &a3.identity,
-                    _ => unreachable!(),
-                };
-                if matches!(&state.beta, ZetaAutomata::A1(_)) {
-                    log!(app, TimeoutX1(session));
-                } else {
-                    log!(app, TimeoutX3(session));
-                }
-                let new_kid_recv = remap(ctx, session, &state);
-
-                let hash = &mut App::Hash::new();
-                let hmac = &mut App::HmacHash::new();
-                if let Some(a1) = create_a1_state(
-                    hash,
-                    hmac,
-                    &ctx.rng,
-                    &session.s_remote,
-                    new_kid_recv,
-                    &state.ratchet_state1,
-                    state.ratchet_state2.as_ref(),
-                    identity,
-                ) {
-                    let mut hk_recv = Zeroizing::new([0u8; HASHLEN]);
-                    let mut hk_send = Zeroizing::new([0u8; HASHLEN]);
-                    a1.noise.get_ask(hmac, LABEL_HEADER_KEY, &mut hk_recv, &mut hk_send);
-                    let mut x1 = a1.x1.clone();
-
-                    drop(state);
-                    let resend_timer = {
-                        let mut state = session.state.write().unwrap();
-                        session
-                            .hk_recv
-                            .reset((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap());
-                        session
-                            .hk_send
-                            .reset((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap());
-                        *state.key_mut(true) = DuplexKey::default();
-                        state.key_mut(true).recv.kid = Some(new_kid_recv);
-                        let resend_timer = current_time + App::SETTINGS.resend_time as i64;
-                        state.resend_timer = AtomicI64::new(resend_timer);
-                        state.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
-                        state.beta = ZetaAutomata::A1(a1);
-                        resend_timer
-                    };
-                    drop(kex_lock);
-
-                    send(&mut x1, None);
-                    Some(resend_timer)
-                } else {
-                    None
-                }
-            }
-            ZetaAutomata::S2 => {
-                // Corresponds to Transition Algorithm 6 found in Section 4.3.
-                log!(app, StartedRekeyingSentK1(session));
-                let new_kid_recv = remap(ctx, session, &state);
-                //    -> s
-                //    <- s
-                //    ...
-                //    -> psk, e, es, ss
-                let mut noise = SymmetricState::initialize(PROTOCOL_NAME_NOISE_KK);
-                let hash = &mut App::Hash::new();
-                let hmac = &mut App::HmacHash::new();
-                let mut k1 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
-                k1.extend([0u8; HEADER_SIZE]);
-                // Noise process prologue.
-                noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
-                noise.mix_hash(hash, &session.s_remote.to_bytes());
-                // Process message pattern 1 psk0 token.
-                noise.mix_key_and_hash(hash, hmac, state.ratchet_state1.key.as_ref());
-                // Process message pattern 1 e token.
-                let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut k1);
-                // Process message pattern 1 es token.
-                if noise.mix_dh(hmac, &e_secret, &session.s_remote).is_none() {
-                    return None;
-                }
-                // Process message pattern 1 ss token.
-                noise.mix_key(hmac, session.noise_kk_ss.as_ref());
-                // Process message pattern 1 payload.
-                let i = k1.len();
-                k1.extend(new_kid_recv.get().to_be_bytes());
-                let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..]);
-                k1.extend(tag);
-
-                drop(state);
-                let resend_timer = {
-                    let mut state = session.state.write().unwrap();
-                    state.key_mut(true).recv.kid = Some(new_kid_recv);
-                    state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-                    let resend_timer = current_time + App::SETTINGS.resend_time as i64;
-                    state.resend_timer = AtomicI64::new(resend_timer);
-                    state.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
-                    resend_timer
-                };
-                drop(kex_lock);
-                let state = session.state.read().unwrap();
-
-                if let Some((c, _)) = get_counter(session, &state) {
-                    let nonce = to_nonce(PACKET_TYPE_REKEY_INIT, c);
-                    let tag = App::Aead::encrypt_in_place(
-                        state.key_ref(false).send.kek.as_ref().unwrap(),
-                        &nonce,
-                        &[],
-                        &mut k1,
-                    );
-                    k1.extend(tag);
-                    set_header(&mut k1, state.key_ref(false).send.kid.unwrap().get(), &nonce);
-
-                    send(&mut k1, Some(&session.hk_send));
-                }
-                Some(resend_timer)
-            }
-            ZetaAutomata::S1 { .. } => {
-                log!(app, TimeoutKeyConfirm(session));
-                None
-            }
-            ZetaAutomata::R1 { .. } => {
-                log!(app, TimeoutK1(session));
-                None
-            }
-            ZetaAutomata::R2 { .. } => {
-                log!(app, TimeoutK2(session));
-                None
-            }
-        }
+        timeout_trans(app, ctx, session, kex_lock, state, current_time, send)
     } else {
         let ts = state.resend_timer.load(Ordering::Relaxed);
         let resend_next = current_time + App::SETTINGS.resend_time as i64;
-        if force_resend || (ts <= current_time && state.resend_timer.fetch_max(resend_next, Ordering::Relaxed) == ts) {
+        if ts <= current_time && state.resend_timer.fetch_max(resend_next, Ordering::Relaxed) == ts {
             // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
 
-            let (packet_type, mut control_payload) = match &state.beta {
+            let (packet_type, control_payload) = match &state.beta {
                 ZetaAutomata::Null => return None,
                 ZetaAutomata::A1(a1) => {
                     log!(app, ResentX1(session));
@@ -1349,23 +1362,8 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
                     (PACKET_TYPE_REKEY_COMPLETE, k2.clone())
                 }
             };
-            if let Some((c, _)) = get_counter(session, &state) {
-                let nonce = to_nonce(packet_type, c);
-                let tag = App::Aead::encrypt_in_place(
-                    state.key_ref(false).send.kek.as_ref().unwrap(),
-                    &nonce,
-                    &[],
-                    &mut control_payload,
-                );
-                control_payload.extend(tag);
-                set_header(
-                    &mut control_payload,
-                    state.key_ref(false).send.kid.unwrap().get(),
-                    &nonce,
-                );
 
-                send(&mut control_payload, Some(&session.hk_send));
-            }
+            send_control(session, &state, packet_type, control_payload, send);
             Some(resend_next)
         } else {
             Some(ts)
@@ -1537,13 +1535,10 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
             .change_priority(session.queue_idx, Reverse(resend_timer));
         let state = session.state.read().unwrap();
 
-        let (c, _) = get_counter(session, &state).ok_or(byzantine_fault!(ExpiredCounter, false))?;
-        let nonce = to_nonce(PACKET_TYPE_REKEY_COMPLETE, c);
-        let tag = App::Aead::encrypt_in_place(state.key_ref(false).send.kek.as_ref().unwrap(), &nonce, &[], &mut k2);
-        k2.extend(tag);
-        set_header(&mut k2, state.key_ref(false).send.kid.unwrap().get(), &nonce);
+        if !send_control(session, &state, PACKET_TYPE_REKEY_COMPLETE, k2, send) {
+            return Err(byzantine_fault!(OutOfSequence, true));
+        }
 
-        send(&mut k2, Some(&session.hk_send));
         Ok(())
     })();
 
@@ -1646,7 +1641,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             noise.split(hmac, &mut nk_recv, &mut nk_send);
 
             drop(state);
-            let (current_time, resend_timer) = {
+            let resend_timer = {
                 let mut state = session.state.write().unwrap();
                 state.key_mut(true).replace_nk(&nk_send, &nk_recv);
                 state.key_mut(true).send.kid = Some(kid_send);
@@ -1660,14 +1655,20 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
                 state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
                 state.resend_timer = AtomicI64::new(resend_timer);
                 state.beta = ZetaAutomata::S1;
-                (current_time, resend_timer)
+                resend_timer
             };
             drop(kex_lock);
             ctx.session_queue
                 .lock()
                 .unwrap()
                 .change_priority(session.queue_idx, Reverse(resend_timer));
-            process_timers(app, ctx, session, current_time, false, true, send);
+            let state = session.state.read().unwrap();
+
+            let mut c1 = ArrayVec::<u8, HEADERED_KEY_CONFIRMATION_SIZE>::new();
+            c1.extend([0u8; HEADER_SIZE]);
+            if !send_control(&session, &state, PACKET_TYPE_KEY_CONFIRM, c1, send) {
+                return Err(byzantine_fault!(OutOfSequence, true));
+            }
 
             Ok(())
         } else {
@@ -1726,9 +1727,16 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
         let j = i + fragment_len;
 
         mtu_sized_buffer[FRAGMENT_NO_IDX] = fragment_no as u8;
-        cipher.encrypt(&payload[i..j], &mut mtu_sized_buffer[HEADER_SIZE..HEADER_SIZE + fragment_len]);
+        cipher.encrypt(
+            &payload[i..j],
+            &mut mtu_sized_buffer[HEADER_SIZE..HEADER_SIZE + fragment_len],
+        );
 
-        session.hk_send.encrypt_in_place((&mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap());
+        session.hk_send.encrypt_in_place(
+            (&mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END])
+                .try_into()
+                .unwrap(),
+        );
 
         if !send(&mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
             return Ok(());
diff --git a/src/zssp.rs b/src/zssp.rs
index ff7eed5..6df421b 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -12,28 +12,24 @@ use std::cmp::Reverse;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::io::Write;
-use std::num::{NonZeroU32, NonZeroU64};
-use std::ops::DerefMut;
-use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
-use std::sync::{Arc, Mutex, MutexGuard, RwLock, Weak};
+use std::num::NonZeroU32;
+use std::sync::{Arc, Mutex, RwLock, Weak};
 
 use arrayvec::ArrayVec;
-use zeroize::Zeroizing;
+use rand_core::RngCore;
 
 use crate::challenge::ChallengeContext;
 use crate::crypto::*;
-use rand_core::RngCore;
 use crate::zeta::*;
 
+use crate::application::*;
 use crate::frag_cache::UnassociatedFragCache;
-use crate::fragged::{Assembled, Fragged};
+use crate::fragged::Assembled;
 use crate::handshake_cache::UnassociatedHandshakeCache;
-use crate::indexed_heap::{BinaryHeapIndex, IndexedBinaryHeap};
+use crate::indexed_heap::IndexedBinaryHeap;
 use crate::log_event::LogEvent;
 use crate::proto::*;
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError, SessionEvent};
-use crate::symmetric_state::SymmetricState;
-use crate::application::*;
 
 /// Macro to turn off logging at compile time.
 macro_rules! log {
@@ -72,13 +68,6 @@ pub struct ContextInner<App: ApplicationLayer> {
     pub(crate) challenge: ChallengeContext,
 }
 
-#[derive(Debug, PartialEq, Eq)]
-pub enum IncomingSessionAction {
-    Allow,
-    Challenge,
-    Drop,
-}
-
 fn parse_fragment_header<StorageError>(
     incoming_fragment: &[u8],
 ) -> Result<(usize, usize, [u8; AES_GCM_IV_SIZE]), ReceiveError<StorageError>> {
@@ -161,7 +150,7 @@ impl<App: ApplicationLayer> Context<App> {
     pub fn open(
         &self,
         app: App,
-        mut send: impl FnMut(&mut [u8]) -> bool,
+        send: impl FnMut(&mut [u8]) -> bool,
         mut mtu: usize,
         static_remote_key: App::PublicKey,
         session_data: App::SessionData,
@@ -217,9 +206,7 @@ impl<App: ApplicationLayer> Context<App> {
     ///   to put in-flight.
     pub fn receive<'a, SendFn: FnMut(&mut [u8]) -> bool>(
         &self,
-        app: &App,
-        check_allow_incoming_session: impl FnOnce() -> IncomingSessionAction,
-        check_accept_session: impl FnOnce(&App::PublicKey, &[u8], u64) -> (Option<(bool, App::SessionData)>, bool),
+        app: App,
         mut send_unassociated_reply: impl FnMut(&mut [u8]) -> bool,
         mut send_unassociated_mtu: usize,
         mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
@@ -350,14 +337,22 @@ impl<App: ApplicationLayer> Context<App> {
                     match packet_type {
                         PACKET_TYPE_HANDSHAKE_RESPONSE => {
                             log!(app, ReceivedRawX2);
-                            received_x2_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet, send_associated)?;
+                            received_x2_trans(
+                                &app,
+                                ctx,
+                                &session,
+                                kid_recv,
+                                &nonce,
+                                assembled_packet,
+                                send_associated,
+                            )?;
                             log!(app, X2IsAuthSentX3(&session));
                             SessionEvent::Control
                         }
                         PACKET_TYPE_KEY_CONFIRM => {
                             log!(app, ReceivedRawKeyConfirm);
                             let result = received_c1_trans(
-                                app,
+                                &app,
                                 ctx,
                                 &session,
                                 kid_recv,
@@ -374,19 +369,35 @@ impl<App: ApplicationLayer> Context<App> {
                         }
                         PACKET_TYPE_ACK => {
                             log!(app, ReceivedRawAck);
-                            received_c2_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet)?;
+                            received_c2_trans(&app, ctx, &session, kid_recv, &nonce, assembled_packet)?;
                             log!(app, AckIsAuth(&session));
                             SessionEvent::Control
                         }
                         PACKET_TYPE_REKEY_INIT => {
                             log!(app, ReceivedRawK1);
-                            received_k1_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet, send_associated)?;
+                            received_k1_trans(
+                                &app,
+                                ctx,
+                                &session,
+                                kid_recv,
+                                &nonce,
+                                assembled_packet,
+                                send_associated,
+                            )?;
                             log!(app, K1IsAuthSentK2(&session));
                             SessionEvent::Control
                         }
                         PACKET_TYPE_REKEY_COMPLETE => {
                             log!(app, ReceivedRawK2);
-                            received_k2_trans(app, ctx, &session, kid_recv, &nonce, assembled_packet, send_associated)?;
+                            received_k2_trans(
+                                &app,
+                                ctx,
+                                &session,
+                                kid_recv,
+                                &nonce,
+                                assembled_packet,
+                                send_associated,
+                            )?;
                             log!(app, K2IsAuthSentKeyConfirm(&session));
                             SessionEvent::Control
                         }
@@ -454,7 +465,7 @@ impl<App: ApplicationLayer> Context<App> {
                     }
 
                     log!(app, ReceivedRawX3);
-                    let session = received_x3_trans(app, ctx, zeta, kid_recv, assembled_packet, |packet, hk_send| {
+                    let session = received_x3_trans(&app, ctx, zeta, kid_recv, assembled_packet, |packet, hk_send| {
                         send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
                     })?;
                     log!(app, X3IsAuthSentKeyConfirm(&session));
@@ -514,32 +525,38 @@ impl<App: ApplicationLayer> Context<App> {
                     return Err(byzantine_fault!(InvalidPacket, true));
                 }
                 // Process recv challenge layer.
-                let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
-                let result = ctx.challenge.process_hello::<App::Hash>(
-                    remote_address,
-                    (&assembled_packet[challenge_start..]).try_into().unwrap(),
-                );
-                if let Err(challenge) = result {
-                    log!(app, X1FailedChallengeSentNewChallenge);
-                    let mut challenge_packet = ArrayVec::<u8, HEADERED_CHALLENGE_SIZE>::new();
-                    challenge_packet.extend([0u8; HEADER_SIZE]);
-                    challenge_packet
-                        .try_extend_from_slice(&assembled_packet[..KID_SIZE])
-                        .unwrap();
-                    challenge_packet.extend(challenge);
-                    let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
-                    challenge_packet[FRAGMENT_COUNT_IDX] = 1;
-                    challenge_packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce);
+                match app.incoming_session() {
+                    IncomingSessionAction::Allow => {}
+                    IncomingSessionAction::Challenge => {
+                        let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
+                        let result = ctx.challenge.process_hello::<App::Hash>(
+                            remote_address,
+                            (&assembled_packet[challenge_start..]).try_into().unwrap(),
+                        );
+                        if let Err(challenge) = result {
+                            log!(app, X1FailedChallengeSentNewChallenge);
+                            let mut challenge_packet = ArrayVec::<u8, HEADERED_CHALLENGE_SIZE>::new();
+                            challenge_packet.extend([0u8; HEADER_SIZE]);
+                            challenge_packet
+                                .try_extend_from_slice(&assembled_packet[..KID_SIZE])
+                                .unwrap();
+                            challenge_packet.extend(challenge);
+                            let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
+                            challenge_packet[FRAGMENT_COUNT_IDX] = 1;
+                            challenge_packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce);
 
-                    send_unassociated_reply(&mut challenge_packet);
-                    // If we issue a challenge the first hello packet will always fail.
-                    return Err(byzantine_fault!(FailedAuth, false));
-                } else {
-                    log!(app, X1SucceededChallenge);
+                            send_unassociated_reply(&mut challenge_packet);
+                            // If we issue a challenge the first hello packet will always fail.
+                            return Err(byzantine_fault!(FailedAuth, false));
+                        } else {
+                            log!(app, X1SucceededChallenge);
+                        }
+                    }
+                    IncomingSessionAction::Drop => return Err(ReceiveError::Rejected),
                 }
 
                 // Process recv zeta layer.
-                received_x1_trans(app, ctx, &nonce, assembled_packet, |packet, hk_send| {
+                received_x1_trans(&app, ctx, &nonce, assembled_packet, |packet, hk_send| {
                     send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
                 })?;
                 log!(app, X1IsAuthSentX2);
@@ -619,15 +636,10 @@ impl<App: ApplicationLayer> Context<App> {
                     continue;
                 }
             };
-            let result = process_timers(&app, ctx, &session, current_time, false, false, |packet, hk_send| {
+            let result = process_timers(&app, ctx, &session, current_time, |packet, hk_send| {
                 if let Some((send_fragment, mut mtu)) = send_to(&session) {
                     mtu = mtu.max(MIN_TRANSPORT_MTU);
-                    send_with_fragmentation(
-                        send_fragment,
-                        mtu,
-                        packet,
-                        hk_send
-                    );
+                    send_with_fragmentation(send_fragment, mtu, packet, hk_send);
                 }
             });
             if let Some(next_timer) = result {

From ccea68abe64c0633d96061e2edfb9a400555e34b Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 11:05:01 -0400
Subject: [PATCH 22/50] refactor

---
 Cargo.lock                   | 238 +++++++++++++++++++++++++++++++++++
 Cargo.toml                   |  18 ++-
 src/application.rs           |   2 +-
 src/crypto/aes.rs            |  14 +--
 src/crypto/mod.rs            |   1 +
 src/crypto/sha512.rs         |   4 +
 src/crypto_impl/kyber1024.rs |  51 ++++++++
 src/crypto_impl/mod.rs       |  21 ++++
 src/crypto_impl/p384_impl.rs |  39 ++++++
 src/crypto_impl/sha512.rs    |  34 +++++
 src/frag_cache.rs            |   4 +-
 src/fragged.rs               |   4 +-
 src/lib.rs                   |   7 +-
 src/log_event.rs             | 137 ++++++++++----------
 src/proto.rs                 |   2 +-
 src/symmetric_state.rs       |   4 +-
 src/zeta.rs                  |  62 +++++----
 src/zssp.rs                  |  36 +++---
 18 files changed, 549 insertions(+), 129 deletions(-)
 create mode 100644 src/crypto_impl/kyber1024.rs
 create mode 100644 src/crypto_impl/mod.rs
 create mode 100644 src/crypto_impl/p384_impl.rs
 create mode 100644 src/crypto_impl/sha512.rs

diff --git a/Cargo.lock b/Cargo.lock
index e0caaa4..81b8afa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,6 +11,181 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "795bc6e66a8e340f075fcf6227e417a2dc976b92b91f3cdc778bb858778b6747"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4c2f4e1afd912bc40bfd6fed5d9dc1f288e0ba01bfcc835cc5bc3eb13efe15"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "968405c8fdc9b3bf4df0a6638858cc0b52462836ab6b1c87377785dd09cf1c0b"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "hkdf",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hkdf"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "791a029f6b9fc27657f6f188ec6e5e43f6911f6f878e0dc5501396e09809d437"
+dependencies = [
+ "hmac",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.147"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
+
+[[package]]
+name = "p384"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70786f51bcc69f6a4c0360e063a4cac5419ef7c5cd5b3c99ad70f3be5ba79209"
+dependencies = [
+ "elliptic-curve",
+ "primeorder",
+]
+
 [[package]]
 name = "pqc_kyber"
 version = "0.6.0"
@@ -20,11 +195,71 @@ dependencies = [
  "rand_core",
 ]
 
+[[package]]
+name = "primeorder"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c2fcef82c0ec6eefcc179b978446c399b3cdf73c392c35604e399eee6df1ee3"
+dependencies = [
+ "elliptic-curve",
+]
+
 [[package]]
 name = "rand_core"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479fb9d862239e610720565ca91403019f2f00410f1864c5aa7479b950a76ed8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "subtle"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+
+[[package]]
+name = "typenum"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "zeroize"
@@ -37,7 +272,10 @@ name = "zssp"
 version = "0.0.3"
 dependencies = [
  "arrayvec",
+ "hmac",
+ "p384",
  "pqc_kyber",
  "rand_core",
+ "sha2",
  "zeroize",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index ca0967b..9b02171 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,7 +11,21 @@ path = "src/lib.rs"
 doc = true
 
 [dependencies]
-pqc_kyber = { version = "0.6.0", default-features = false, features = ["kyber1024", "std"] }
-rand_core = "0.6.4"
+rand_core = { version = "0.6.4" }
 zeroize = { version = "1.6.0" }
 arrayvec = { version = "0.7.4", default-features = false, features = ["std", "zeroize"] }
+
+pqc_kyber = { version = "0.6.0", default-features = false, features = ["kyber1024", "std"], optional = true }
+p384 = { version = "0.13.0", default-features = false, features = ["ecdh"], optional = true }
+sha2 = { version = "0.10.7", default-features = false, optional = true }
+hmac = { version = "0.12.1", default-features = false, optional = true }
+
+[features]
+default = ["debug", "p384", "hmac", "pqc_kyber"]
+sha2 = ["dep:sha2"]
+hmac = ["dep:hmac", "sha2"]
+logging = []
+debug = ["logging"]
+
+[dev-dependencies]
+rand_core = { version = "0.6.4", features = ["getrandom"] }
diff --git a/src/application.rs b/src/application.rs
index 705cdad..48dc269 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -247,7 +247,7 @@ pub trait ApplicationLayer: Sized {
     /// These are provided for debugging, logging or metrics purposes, and must be used for
     /// nothing else. Do not base protocol-level decisions upon the events passed to this function.
     #[cfg(feature = "logging")]
-    fn event_log(&self, event: LogEvent<'_, Self>);
+    fn event_log(&self, event: crate::LogEvent<'_, Self>);
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index 9a4e242..8368e08 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -3,7 +3,7 @@
 pub const AES_256_KEY_SIZE: usize = 32;
 pub const AES_256_BLOCK_SIZE: usize = 16;
 pub const AES_GCM_TAG_SIZE: usize = 16;
-pub const AES_GCM_IV_SIZE: usize = 12;
+pub const AES_GCM_NONCE_SIZE: usize = 12;
 
 /// A trait for encrypting individual blocks of plaintext using AES-256.
 /// It is used for header authentication, for which we have a standard model proof that our
@@ -15,7 +15,7 @@ pub trait AesEnc: Send + Sync {
 
     /// Change the encryption key to `key` so that all future encryption is performed with it.
     /// This function is very rarely called so it does not have to be particularly efficient.
-    fn reset(&self, key: &[u8; AES_256_KEY_SIZE]);
+    fn reset(&mut self, key: &[u8; AES_256_KEY_SIZE]);
 
     /// Decrypt the given `block` of plaintext directly using the AES block cipher
     /// (i.e. AES-256 in zero-padding ECB mode).
@@ -31,7 +31,7 @@ pub trait AesDec: Send + Sync {
 
     /// Change the decryption key to `key` so that all future decryption is performed with it.
     /// This function is very rarely called so it does not have to be particularly efficient.
-    fn reset(&self, key: &[u8; AES_256_KEY_SIZE]);
+    fn reset(&mut self, key: &[u8; AES_256_KEY_SIZE]);
 
     /// Decrypt the given `block` of ciphertext directly using the AES 256 block cipher
     /// (i.e. AES-256 in zero-padding ECB mode).
@@ -62,21 +62,21 @@ pub trait HighThroughputAesGcmPool: Send + Sync {
 
     fn new(encrypt_key: &[u8; AES_256_KEY_SIZE], decrypt_key: &[u8; AES_256_KEY_SIZE]) -> Self;
 
-    fn start_enc<'a>(&'a self, iv: &[u8; AES_GCM_IV_SIZE]) -> Self::EncContext<'a>;
-    fn start_dec<'a>(&'a self, iv: &[u8; AES_GCM_IV_SIZE]) -> Self::DecContext<'a>;
+    fn start_enc<'a>(&'a self, iv: &[u8; AES_GCM_NONCE_SIZE]) -> Self::EncContext<'a>;
+    fn start_dec<'a>(&'a self, iv: &[u8; AES_GCM_NONCE_SIZE]) -> Self::DecContext<'a>;
 }
 
 pub trait LowThroughputAesGcm {
     fn encrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
-        iv: &[u8; AES_GCM_IV_SIZE],
+        iv: &[u8; AES_GCM_NONCE_SIZE],
         aad: &[u8],
         data: &mut [u8],
     ) -> [u8; AES_GCM_TAG_SIZE];
     #[must_use]
     fn decrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
-        iv: &[u8; AES_GCM_IV_SIZE],
+        iv: &[u8; AES_GCM_NONCE_SIZE],
         aad: &[u8],
         data: &mut [u8],
         tag: &[u8; AES_GCM_TAG_SIZE],
diff --git a/src/crypto/mod.rs b/src/crypto/mod.rs
index 00ca2aa..16279f0 100644
--- a/src/crypto/mod.rs
+++ b/src/crypto/mod.rs
@@ -13,6 +13,7 @@ pub use kyber1024::*;
 // We re-export our dependencies so it is less of a headache for the implementor to use the same
 // exact version of them.
 pub use rand_core;
+pub use zeroize;
 
 /// Constant time byte slice equality.
 pub fn secure_eq<A: AsRef<[u8]> + ?Sized, B: AsRef<[u8]> + ?Sized>(a: &A, b: &B) -> bool {
diff --git a/src/crypto/sha512.rs b/src/crypto/sha512.rs
index 94178c1..32a0a82 100644
--- a/src/crypto/sha512.rs
+++ b/src/crypto/sha512.rs
@@ -17,6 +17,10 @@ pub trait HashSha512 {
 /// Does not need to be threadsafe.
 pub trait HmacSha512 {
     /// Allocate space on the stack or heap for repeated Hmac invocations.
+    ///
+    /// Many FIPS compliant libraries, namely OpenSSL, require initializing an Hmac context on the
+    /// heap before operating on it.
+    /// If you are using a more sane library feel free to make this return an empty type.
     fn new() -> Self;
     /// Pure function for computing a single HMAC Hash. Repeat invocations of this function should
     /// have no effect on each other.
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
new file mode 100644
index 0000000..d2db360
--- /dev/null
+++ b/src/crypto_impl/kyber1024.rs
@@ -0,0 +1,51 @@
+use rand_core::{CryptoRng, RngCore};
+use zeroize::Zeroizing;
+
+use crate::crypto::*;
+
+/// A wrapper for a buffer the size of a pqc_kyber secret key.
+/// The crate `pqc_kyber` is low level and operates directly on buffers of bytes.
+pub type RustKyber1024PrivateKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
+impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for RustKyber1024PrivateKey {
+    fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
+        let keypair = pqc_kyber::keypair(rng);
+        (Zeroizing::new(keypair.secret), keypair.public)
+    }
+
+    fn encapsulate(
+        rng: &mut Rng,
+        public_key: &[u8; KYBER_PUBLIC_KEY_SIZE],
+        plaintext_out: &mut [u8; KYBER_PLAINTEXT_SIZE],
+    ) -> Option<[u8; KYBER_CIPHERTEXT_SIZE]> {
+        let ret;
+        (ret, *plaintext_out) = pqc_kyber::encapsulate(public_key, rng).ok()?;
+        Some(ret)
+    }
+
+    fn decapsulate(
+        &self,
+        ciphertext: &[u8; KYBER_CIPHERTEXT_SIZE],
+        plaintext_out: &mut [u8; KYBER_PLAINTEXT_SIZE],
+    ) -> bool {
+        if let Ok(result) = pqc_kyber::decapsulate(ciphertext, self.as_ref()) {
+            *plaintext_out = result;
+            true
+        } else {
+            false
+        }
+    }
+}
+
+//impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for RustKyber1024PrivateKey {
+//    fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
+//    }
+
+//    fn encapsulate(
+//        rng: &mut Rng,
+//        public_key: &[u8; KYBER_PUBLIC_KEY_SIZE],
+//    ) -> Option<([u8; KYBER_CIPHERTEXT_SIZE], [u8; KYBER_PLAINTEXT_SIZE])> {
+//    }
+
+//    fn decapsulate(&self, ciphertext: &[u8; KYBER_CIPHERTEXT_SIZE]) -> Option<[u8; KYBER_PLAINTEXT_SIZE]> {
+//    }
+//}
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
new file mode 100644
index 0000000..e24f28d
--- /dev/null
+++ b/src/crypto_impl/mod.rs
@@ -0,0 +1,21 @@
+#[cfg(feature = "pqc_kyber")]
+mod kyber1024;
+#[cfg(feature = "pqc_kyber")]
+pub use kyber1024::*;
+#[cfg(feature = "p384")]
+mod p384_impl;
+#[cfg(feature = "p384")]
+pub use p384_impl::*;
+#[cfg(feature = "sha2")]
+mod sha512;
+#[cfg(feature = "sha2")]
+pub use sha512::*;
+
+#[cfg(feature = "hmac")]
+pub use hmac;
+#[cfg(feature = "p384")]
+pub use p384;
+#[cfg(feature = "pqc_kyber")]
+pub use pqc_kyber;
+#[cfg(feature = "sha2")]
+pub use sha2;
diff --git a/src/crypto_impl/p384_impl.rs b/src/crypto_impl/p384_impl.rs
new file mode 100644
index 0000000..d65028a
--- /dev/null
+++ b/src/crypto_impl/p384_impl.rs
@@ -0,0 +1,39 @@
+use p384::{ecdh::EphemeralSecret, CompressedPoint, PublicKey};
+use rand_core::{CryptoRng, RngCore};
+
+use crate::crypto::*;
+
+pub type RustP384PublicKey = PublicKey;
+impl P384PublicKey for PublicKey {
+    fn from_bytes(raw_key: &[u8; P384_PUBLIC_KEY_SIZE]) -> Option<Self> {
+        PublicKey::from_sec1_bytes(raw_key).ok()
+    }
+
+    fn to_bytes(&self) -> [u8; P384_PUBLIC_KEY_SIZE] {
+        let k = CompressedPoint::from(self);
+        k.as_slice().try_into().unwrap()
+    }
+}
+
+pub type RustP384KeyPair = EphemeralSecret;
+impl<Rng: RngCore + CryptoRng> P384KeyPair<Rng> for RustP384KeyPair {
+    type PublicKey = PublicKey;
+
+    fn generate(rng: &mut Rng) -> Self {
+        EphemeralSecret::random(rng)
+    }
+
+    fn public_key_bytes(&self) -> [u8; P384_PUBLIC_KEY_SIZE] {
+        CompressedPoint::from(self.public_key()).as_slice().try_into().unwrap()
+    }
+
+    fn agree(&self, public_key: &Self::PublicKey, output: &mut [u8; P384_ECDH_SHARED_SECRET_SIZE]) -> bool {
+        *output = self
+            .diffie_hellman(public_key)
+            .raw_secret_bytes()
+            .as_slice()
+            .try_into()
+            .unwrap();
+        true
+    }
+}
diff --git a/src/crypto_impl/sha512.rs b/src/crypto_impl/sha512.rs
new file mode 100644
index 0000000..10dc3b5
--- /dev/null
+++ b/src/crypto_impl/sha512.rs
@@ -0,0 +1,34 @@
+use hmac::{Hmac, Mac};
+use sha2::{Digest, Sha512};
+
+use crate::crypto::*;
+
+pub type RustSha512 = Sha512;
+impl HashSha512 for RustSha512 {
+    fn new() -> Self {
+        Digest::new()
+    }
+
+    fn update(&mut self, data: &[u8]) {
+        Digest::update(self, data)
+    }
+
+    fn finish_and_reset(&mut self, output: &mut [u8; SHA512_HASH_SIZE]) {
+        let mut hasher = Digest::new();
+        std::mem::swap(self, &mut hasher);
+        *output = hasher.finalize().into();
+    }
+}
+
+pub struct RustHmac;
+impl HmacSha512 for RustHmac {
+    fn new() -> Self {
+        RustHmac
+    }
+
+    fn hash(&mut self, key: &[u8], full_input: &[u8], output: &mut [u8; SHA512_HASH_SIZE]) {
+        let mut hm = Hmac::<Sha512>::new_from_slice(key).unwrap();
+        hm.update(full_input);
+        *output = hm.finalize().into_bytes().into()
+    }
+}
diff --git a/src/frag_cache.rs b/src/frag_cache.rs
index cbe95df..2423cda 100644
--- a/src/frag_cache.rs
+++ b/src/frag_cache.rs
@@ -10,7 +10,7 @@ use std::collections::hash_map::RandomState;
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::mem::MaybeUninit;
 
-use crate::crypto::AES_GCM_IV_SIZE;
+use crate::crypto::AES_GCM_NONCE_SIZE;
 use crate::fragged::Assembled;
 use crate::proto::{MAX_FRAGMENTS, MAX_UNASSOCIATED_FRAGMENTS, MAX_UNASSOCIATED_PACKETS, MAX_UNASSOCIATED_PACKET_SIZE};
 
@@ -56,7 +56,7 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
     /// Will check that aad is the same for all fragments.
     pub(crate) fn assemble(
         &mut self,
-        nonce: &[u8; AES_GCM_IV_SIZE],
+        nonce: &[u8; AES_GCM_NONCE_SIZE],
         remote_address: impl Hash,
         fragment_size: usize,
         fragment: Fragment,
diff --git a/src/fragged.rs b/src/fragged.rs
index 38a0e18..54b90d9 100644
--- a/src/fragged.rs
+++ b/src/fragged.rs
@@ -9,7 +9,7 @@
 use arrayvec::ArrayVec;
 use std::mem::{needs_drop, zeroed, MaybeUninit};
 
-use crate::crypto::AES_GCM_IV_SIZE;
+use crate::crypto::AES_GCM_NONCE_SIZE;
 use crate::proto::{MAX_FRAGMENTS, NONCE_SIZE_DIFF};
 
 pub type Assembled<Fragment> = ArrayVec<Fragment, MAX_FRAGMENTS>;
@@ -37,7 +37,7 @@ impl<Fragment, const MAX_FRAGMENTS: usize> Fragged<Fragment, MAX_FRAGMENTS> {
     /// Will check that aad is the same for all fragments.
     pub(crate) fn assemble(
         &mut self,
-        nonce: &[u8; AES_GCM_IV_SIZE],
+        nonce: &[u8; AES_GCM_NONCE_SIZE],
         fragment: Fragment,
         fragment_no: usize,
         fragment_count: usize,
diff --git a/src/lib.rs b/src/lib.rs
index bd202c4..36c2fcd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,6 +6,7 @@
  * https://www.zerotier.com/
  */
 pub mod crypto;
+pub mod crypto_impl;
 
 mod antireplay;
 pub mod application;
@@ -14,14 +15,16 @@ mod frag_cache;
 mod fragged;
 mod handshake_cache;
 mod indexed_heap;
-pub mod log_event;
+
+mod log_event;
+pub use log_event::*;
+
 pub mod proto;
 pub mod ratchet_state;
 pub mod result;
 mod symmetric_state;
 pub mod zeta;
 pub mod zssp;
-//mod context;
 
 //pub mod error;
 //pub use crate::applicationlayer::ApplicationLayer;
diff --git a/src/log_event.rs b/src/log_event.rs
index 1cb6522..283ae3a 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -1,77 +1,88 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
 use std::sync::Arc;
 
-use crate::{application::ApplicationLayer, zeta::Session};
+use crate::application::ApplicationLayer;
+use crate::zeta::Session;
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
-pub enum LogEvent<'a, Application: ApplicationLayer> {
-    ServiceXK1Resend(&'a Arc<Session<Application>>),
-    ServiceXK3Resend(&'a Arc<Session<Application>>),
-    ServiceXKTimeout(&'a Arc<Session<Application>>),
-    ServiceKKStart(&'a Arc<Session<Application>>),
-    ServiceKK1Resend(&'a Arc<Session<Application>>),
-    ServiceKK2Resend(&'a Arc<Session<Application>>),
-    ServiceKKTimeout(&'a Arc<Session<Application>>),
-    ServiceKeyConfirmResend(&'a Arc<Session<Application>>),
-    ServiceKeyConfirmTimeout(&'a Arc<Session<Application>>),
-    /// `(fragment_count, fragment_no, packet_type)`
-    ReceiveUnassociatedFragment(u8, u8, u8),
-    ReceiveUncheckedXK1,
-    ReceiveCheckXK1Challenge(bool),
-    ReceiveValidXK1,
-    ReceiveUncheckedDOSChallenge,
-    ReceiveValidDOSChallenge(&'a Arc<Session<Application>>),
-    ReceiveUncheckedXK2,
-    ReceiveValidXK2(&'a Arc<Session<Application>>),
-    ReceiveUncheckedXK3,
-    ReceiveValidXK3(&'a Application::SessionData),
-    ReceiveUncheckedKK1,
-    ReceiveValidKK1(&'a Arc<Session<Application>>),
-    ReceiveUncheckedKK2,
-    ReceiveValidKK2(&'a Arc<Session<Application>>),
-    ReceiveValidKeyConfirm(&'a Arc<Session<Application>>),
-    ReceiveValidAck(&'a Arc<Session<Application>>),
+pub enum LogEvent<'a, App: ApplicationLayer> {
+    ResentX1(&'a Arc<Session<App>>),
+    TimeoutX1(&'a Arc<Session<App>>),
+    TimeoutX2,
+    ResentX3(&'a Arc<Session<App>>),
+    TimeoutX3(&'a Arc<Session<App>>),
+    ResentKeyConfirm(&'a Arc<Session<App>>),
+    TimeoutKeyConfirm(&'a Arc<Session<App>>),
+    StartedRekeyingSentK1(&'a Arc<Session<App>>),
+    ResentK1(&'a Arc<Session<App>>),
+    TimeoutK1(&'a Arc<Session<App>>),
+    ResentK2(&'a Arc<Session<App>>),
+    TimeoutK2(&'a Arc<Session<App>>),
+    /// `(packet_type, packet_counter, fragment_no, fragment_count)`
+    ReceivedRawFragment(u8, u64, usize, usize),
+    ReceivedRawX1,
+    X1FailedChallengeSentNewChallenge,
+    X1SucceededChallenge,
+    X1IsAuthSentX2,
+    ReceivedRawChallenge,
+    ChallengeIsAuth(&'a Arc<Session<App>>),
+    ReceivedRawX2,
+    X2IsAuthSentX3(&'a Arc<Session<App>>),
+    ReceivedRawX3,
+    X3IsAuthSentKeyConfirm(&'a Arc<Session<App>>),
+    ReceivedRawKeyConfirm,
+    KeyConfirmIsAuthSentAck(&'a Arc<Session<App>>),
+    ReceivedRawAck,
+    AckIsAuth(&'a Arc<Session<App>>),
+    ReceivedRawK1,
+    K1IsAuthSentK2(&'a Arc<Session<App>>),
+    ReceivedRawK2,
+    K2IsAuthSentKeyConfirm(&'a Arc<Session<App>>),
+    ReceivedRawD,
+    DIsAuthClosedSession(&'a Arc<Session<App>>),
 }
-impl<'a, Application: ApplicationLayer> std::fmt::Debug for LogEvent<'a, Application> {
+
+impl<'a, App: ApplicationLayer> std::fmt::Debug for LogEvent<'a, App> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use LogEvent::*;
         match self {
-            ServiceXK1Resend(_) => write!(f, "ServiceXK1Resend"),
-            ServiceXK3Resend(_) => write!(f, "ServiceXK3Resend"),
-            ServiceXKTimeout(_) => write!(f, "ServiceXKTimeout"),
-            ServiceKKStart(_) => write!(f, "ServiceKKStart"),
-            ServiceKK1Resend(_) => write!(f, "ServiceKK1Resend"),
-            ServiceKK2Resend(_) => write!(f, "ServiceKK2Resend"),
-            ServiceKKTimeout(_) => write!(f, "ServiceKKTimeout"),
-            ServiceKeyConfirmResend(_) => write!(f, "ServiceKeyConfirmResend"),
-            ServiceKeyConfirmTimeout(_) => write!(f, "ServiceKeyConfirmTimeout"),
-            ReceiveUnassociatedFragment(arg0, arg1, arg2) => f
-                .debug_tuple("ReceiveUnassociatedFragment")
+            Self::ResentX1(_) => f.debug_tuple("ResentX1").finish(),
+            Self::TimeoutX1(_) => f.debug_tuple("TimeoutX1").finish(),
+            Self::TimeoutX2 => write!(f, "TimeoutX2"),
+            Self::ResentX3(_) => f.debug_tuple("ResentX3").finish(),
+            Self::TimeoutX3(_) => f.debug_tuple("TimeoutX3").finish(),
+            Self::ResentKeyConfirm(_) => f.debug_tuple("ResentKeyConfirm").finish(),
+            Self::TimeoutKeyConfirm(_) => f.debug_tuple("TimeoutKeyConfirm").finish(),
+            Self::StartedRekeyingSentK1(_) => f.debug_tuple("StartedRekeyingSentK1").finish(),
+            Self::ResentK1(_) => f.debug_tuple("ResentK1").finish(),
+            Self::TimeoutK1(_) => f.debug_tuple("TimeoutK1").finish(),
+            Self::ResentK2(_) => f.debug_tuple("ResentK2").finish(),
+            Self::TimeoutK2(_) => f.debug_tuple("TimeoutK2").finish(),
+            Self::ReceivedRawFragment(arg0, arg1, arg2, arg3) => f
+                .debug_tuple("ReceivedRawFragment")
                 .field(arg0)
                 .field(arg1)
                 .field(arg2)
+                .field(arg3)
                 .finish(),
-            ReceiveUncheckedXK1 => write!(f, "ReceiveUncheckedXK1"),
-            ReceiveCheckXK1Challenge(arg0) => f.debug_tuple("ReceiveCheckXK1Challenge").field(arg0).finish(),
-            ReceiveValidXK1 => write!(f, "ReceiveValidXK1"),
-            ReceiveUncheckedDOSChallenge => write!(f, "ReceiveUncheckedDOSChallenge"),
-            ReceiveValidDOSChallenge(_) => write!(f, "ReceiveValidDOSChallenge"),
-            ReceiveUncheckedXK2 => write!(f, "ReceiveUncheckedXK2"),
-            ReceiveValidXK2(_) => write!(f, "ReceiveValidXK2"),
-            ReceiveUncheckedXK3 => write!(f, "ReceiveUncheckedXK3"),
-            ReceiveValidXK3(_) => write!(f, "ReceiveValidXK3"),
-            ReceiveUncheckedKK1 => write!(f, "ReceiveUncheckedKK1"),
-            ReceiveValidKK1(_) => write!(f, "ReceiveValidKK1"),
-            ReceiveUncheckedKK2 => write!(f, "ReceiveUncheckedKK2"),
-            ReceiveValidKK2(_) => write!(f, "ReceiveValidKK2"),
-            ReceiveValidKeyConfirm(_) => write!(f, "ReceiveValidKeyConfirm"),
-            ReceiveValidAck(_) => write!(f, "ReceiveValidAck"),
+            Self::ReceivedRawX1 => write!(f, "ReceivedRawX1"),
+            Self::X1FailedChallengeSentNewChallenge => write!(f, "X1FailedChallengeSentNewChallenge"),
+            Self::X1SucceededChallenge => write!(f, "X1SucceededChallenge"),
+            Self::X1IsAuthSentX2 => write!(f, "X1IsAuthSentX2"),
+            Self::ReceivedRawChallenge => write!(f, "ReceivedRawChallenge"),
+            Self::ChallengeIsAuth(_) => f.debug_tuple("ChallengeIsAuth").finish(),
+            Self::ReceivedRawX2 => write!(f, "ReceivedRawX2"),
+            Self::X2IsAuthSentX3(_) => f.debug_tuple("X2IsAuthSentX3").finish(),
+            Self::ReceivedRawX3 => write!(f, "ReceivedRawX3"),
+            Self::X3IsAuthSentKeyConfirm(_) => f.debug_tuple("X3IsAuthSentKeyConfirm").finish(),
+            Self::ReceivedRawKeyConfirm => write!(f, "ReceivedRawKeyConfirm"),
+            Self::KeyConfirmIsAuthSentAck(_) => f.debug_tuple("KeyConfirmIsAuthSentAck").finish(),
+            Self::ReceivedRawAck => write!(f, "ReceivedRawAck"),
+            Self::AckIsAuth(_) => f.debug_tuple("AckIsAuth").finish(),
+            Self::ReceivedRawK1 => write!(f, "ReceivedRawK1"),
+            Self::K1IsAuthSentK2(_) => f.debug_tuple("K1IsAuthSentK2").finish(),
+            Self::ReceivedRawK2 => write!(f, "ReceivedRawK2"),
+            Self::K2IsAuthSentKeyConfirm(_) => f.debug_tuple("K2IsAuthSentKeyConfirm").finish(),
+            Self::ReceivedRawD => write!(f, "ReceivedRawD"),
+            Self::DIsAuthClosedSession(_) => f.debug_tuple("DIsAuthClosedSession").finish(),
         }
     }
 }
diff --git a/src/proto.rs b/src/proto.rs
index 8c1d252..74ae800 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -51,7 +51,7 @@ pub(crate) const FRAGMENT_COUNT_IDX: usize = 5;
 /// into this number of fragments it will be dropped.
 pub(crate) const MAX_FRAGMENTS: usize = 48;
 
-pub(crate) const NONCE_SIZE_DIFF: usize = AES_GCM_IV_SIZE - PACKET_NONCE_SIZE;
+pub(crate) const NONCE_SIZE_DIFF: usize = AES_GCM_NONCE_SIZE - PACKET_NONCE_SIZE;
 
 /* Key exchange constants */
 /*
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 7349d63..6f23da2 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -165,7 +165,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     pub fn encrypt_and_hash_in_place(
         &mut self,
         hash: &mut App::Hash,
-        iv: [u8; AES_GCM_IV_SIZE],
+        iv: [u8; AES_GCM_NONCE_SIZE],
         data: &mut [u8],
     ) -> [u8; AES_GCM_TAG_SIZE] {
         let tag = App::Aead::encrypt_in_place(&self.k, &iv, &self.h, data);
@@ -180,7 +180,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     pub fn decrypt_and_hash_in_place(
         &mut self,
         hash: &mut App::Hash,
-        iv: [u8; AES_GCM_IV_SIZE],
+        iv: [u8; AES_GCM_NONCE_SIZE],
         data: &mut [u8],
         tag: [u8; AES_GCM_TAG_SIZE],
     ) -> bool {
diff --git a/src/zeta.rs b/src/zeta.rs
index 957faeb..3b71ec4 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -32,8 +32,8 @@ use crate::LogEvent::*;
 /// the key id.
 ///
 /// Corresponds to Figure 10 found in Section 4.3.
-pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_IV_SIZE] {
-    let mut ret = [0u8; AES_GCM_IV_SIZE];
+pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_NONCE_SIZE] {
+    let mut ret = [0u8; AES_GCM_NONCE_SIZE];
     ret[3] = packet_type;
     // Noise requires a big endian counter at the end of the Nonce
     ret[4..].copy_from_slice(&counter.to_be_bytes());
@@ -90,8 +90,6 @@ pub struct Session<App: ApplicationLayer> {
 
     pub window: Window<COUNTER_WINDOW_MAX_OOO, COUNTER_WINDOW_MAX_SKIP_AHEAD>,
     pub(crate) defrag: [Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
-    pub(crate) hk_send: App::PrpEnc,
-    pub(crate) hk_recv: App::PrpDec,
 
     /// `session_queue -> state_machine_lock -> state -> session_map`
     state_machine_lock: Mutex<()>,
@@ -105,13 +103,15 @@ pub(crate) struct MutableState<App: ApplicationLayer> {
     ratchet_state1: RatchetState,
     ratchet_state2: Option<RatchetState>,
 
+    pub(crate) hk_send: App::PrpEnc,
+    pub(crate) hk_recv: App::PrpDec,
     key_creation_counter: u64,
     key_index: bool,
     keys: [DuplexKey<App>; 2],
 
     resend_timer: AtomicI64,
     timeout_timer: i64,
-    pub beta: ZetaAutomata<App>,
+    pub(crate) beta: ZetaAutomata<App>,
 }
 
 /// Corresponds to State B_2 of the Zeta State Machine found in Section 4.1 - Definition 3.
@@ -294,7 +294,7 @@ impl<App: ApplicationLayer> MutableState<App> {
     }
 }
 
-fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_IV_SIZE]) {
+fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_NONCE_SIZE]) {
     packet[..KID_SIZE].copy_from_slice(&kid_send.to_be_bytes());
     packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
 }
@@ -328,7 +328,7 @@ fn create_a1_state<App: ApplicationLayer>(
     let i = x1.len();
     let (e1_secret, e1_public) = App::Kem::generate(rng.lock().unwrap().deref_mut());
     x1.extend(e1_public);
-    x1.extend([0u8; AES_GCM_IV_SIZE]);
+    x1.extend([0u8; AES_GCM_NONCE_SIZE]);
     let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), &mut x1[i..]);
     x1.extend(tag);
     // Process message pattern 1 payload.
@@ -416,6 +416,8 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         state: RwLock::new(MutableState {
             ratchet_state1: state1.clone(),
             ratchet_state2: state2.clone(),
+            hk_send: App::PrpEnc::new((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap()),
+            hk_recv: App::PrpDec::new((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()),
             key_creation_counter: 0,
             key_index: true,
             keys: [DuplexKey::default(), DuplexKey::default()],
@@ -425,8 +427,6 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         }),
         noise_kk_ss: noise_kk_ss.clone(),
         defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
-        hk_send: App::PrpEnc::new((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap()),
-        hk_recv: App::PrpDec::new((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()),
     });
     {
         let mut state = session.state.write().unwrap();
@@ -460,7 +460,7 @@ pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
 pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     app: &App,
     ctx: &ContextInner<App>,
-    n: &[u8; AES_GCM_IV_SIZE],
+    n: &[u8; AES_GCM_NONCE_SIZE],
     x1: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
@@ -473,7 +473,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(InvalidPacket, true));
     }
 
-    if &n[AES_GCM_IV_SIZE - 8..] != &x1[x1.len() - 8..] {
+    if &n[AES_GCM_NONCE_SIZE - 8..] != &x1[x1.len() - 8..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let hash = &mut App::Hash::new();
@@ -609,7 +609,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: &[u8; AES_GCM_IV_SIZE],
+    n: &[u8; AES_GCM_NONCE_SIZE],
     x2: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
@@ -629,7 +629,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(UnknownLocalKeyId, true));
     }
     let (_, c) = from_nonce(n);
-    if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_IV_SIZE - 3..] != &x2[x2.len() - 3..] {
+    if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_NONCE_SIZE - 3..] != &x2[x2.len() - 3..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let mut result = (|| {
@@ -797,7 +797,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             let state = session.state.read().unwrap();
             timeout_trans(app, ctx, session, kex_lock, state, app.time(), send);
         }
-        Ok(ref mut packet) => send(packet, Some(&session.hk_send)),
+        Ok(ref mut packet) => send(packet, Some(&session.state.read().unwrap().hk_send)),
         _ => {}
     }
     result.map(|_| ())
@@ -815,7 +815,7 @@ fn send_control<App: ApplicationLayer, const CAP: usize>(
             let tag = App::Aead::encrypt_in_place(kek, &nonce, &[], &mut payload[HEADER_SIZE..]);
             payload.extend(tag);
             set_header(&mut payload, kid.get(), &nonce);
-            send(&mut payload, Some(&session.hk_send));
+            send(&mut payload, Some(&state.hk_send));
             true
         } else {
             false
@@ -961,6 +961,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                         state: RwLock::new(MutableState {
                             ratchet_state1: new_ratchet_state.clone(),
                             ratchet_state2: None,
+                            hk_send: App::PrpEnc::new(&zeta.hk_send),
+                            hk_recv: App::PrpDec::new(&zeta.hk_recv),
                             key_creation_counter: c + 1,
                             key_index: false,
                             keys: [DuplexKey::default(), DuplexKey::default()],
@@ -972,8 +974,6 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                         queue_idx,
                         noise_kk_ss: noise_kk_ss.clone(),
                         defrag: std::array::from_fn(|_| Mutex::new(Fragged::new())),
-                        hk_send: App::PrpEnc::new(&zeta.hk_send),
-                        hk_recv: App::PrpDec::new(&zeta.hk_recv),
                     });
                     {
                         let mut state = session.state.write().unwrap();
@@ -1012,7 +1012,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: &[u8; AES_GCM_IV_SIZE],
+    n: &[u8; AES_GCM_NONCE_SIZE],
     c1: &[u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<bool, ReceiveError<App::StorageError>> {
@@ -1103,7 +1103,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: &[u8; AES_GCM_IV_SIZE],
+    n: &[u8; AES_GCM_NONCE_SIZE],
     c2: &[u8],
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
@@ -1156,7 +1156,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
 pub(crate) fn received_d_trans<App: ApplicationLayer>(
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: &[u8; AES_GCM_IV_SIZE],
+    n: &[u8; AES_GCM_NONCE_SIZE],
     d: &[u8],
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
@@ -1231,12 +1231,8 @@ fn timeout_trans<App: ApplicationLayer>(
                 drop(state);
                 let resend_timer = {
                     let mut state = session.state.write().unwrap();
-                    session
-                        .hk_recv
-                        .reset((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap());
-                    session
-                        .hk_send
-                        .reset((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap());
+                    state.hk_recv.reset((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap());
+                    state.hk_send.reset((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap());
                     *state.key_mut(true) = DuplexKey::default();
                     state.key_mut(true).recv.kid = Some(new_kid_recv);
                     let resend_timer = current_time + App::SETTINGS.resend_time as i64;
@@ -1343,7 +1339,7 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
                 }
                 ZetaAutomata::A3(a3) => {
                     log!(app, ResentX3(session));
-                    send(&mut a3.x3.clone(), Some(&session.hk_send));
+                    send(&mut a3.x3.clone(), Some(&state.hk_send));
                     return Some(resend_next);
                 }
                 ZetaAutomata::S1 => {
@@ -1391,7 +1387,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: &[u8; AES_GCM_IV_SIZE],
+    n: &[u8; AES_GCM_NONCE_SIZE],
     k1: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
@@ -1553,7 +1549,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     kid: NonZeroU32,
-    n: &[u8; AES_GCM_IV_SIZE],
+    n: &[u8; AES_GCM_NONCE_SIZE],
     k2: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
 ) -> Result<(), ReceiveError<App::StorageError>> {
@@ -1732,7 +1728,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
             &mut mtu_sized_buffer[HEADER_SIZE..HEADER_SIZE + fragment_len],
         );
 
-        session.hk_send.encrypt_in_place(
+        state.hk_send.encrypt_in_place(
             (&mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END])
                 .try_into()
                 .unwrap(),
@@ -1760,14 +1756,14 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
 /// Corresponds to Algorithm 10 found in Section 4.3.
 pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
     session: &Arc<Session<App>>,
+    state: RwLockReadGuard<'_, MutableState<App>>,
     kid: NonZeroU32,
-    n: &[u8; AES_GCM_IV_SIZE],
+    n: &[u8; AES_GCM_NONCE_SIZE],
     fragments: &mut [App::IncomingPacketBuffer],
     mut output_buffer: impl Write,
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
 
-    let state = session.state.read().unwrap();
     let is_other = if Some(kid) == state.key_ref(true).recv.kid {
         true
     } else if Some(kid) == state.key_ref(false).recv.kid {
@@ -1792,7 +1788,7 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
         i += 1;
     }
     let fragment = &mut fragments[i].as_mut()[HEADER_SIZE..];
-    let tag_idx = fragment.len() - AES_GCM_IV_SIZE;
+    let tag_idx = fragment.len() - AES_GCM_NONCE_SIZE;
     cipher.decrypt_in_place(&mut fragment[..tag_idx]);
     if cipher.finish((&fragment[tag_idx..]).try_into().unwrap()) {
         return Err(byzantine_fault!(FailedAuth, true));
diff --git a/src/zssp.rs b/src/zssp.rs
index 6df421b..52e4361 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -27,9 +27,10 @@ use crate::frag_cache::UnassociatedFragCache;
 use crate::fragged::Assembled;
 use crate::handshake_cache::UnassociatedHandshakeCache;
 use crate::indexed_heap::IndexedBinaryHeap;
-use crate::log_event::LogEvent;
 use crate::proto::*;
 use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError, SessionEvent};
+#[cfg(feature = "logging")]
+use crate::LogEvent::*;
 
 /// Macro to turn off logging at compile time.
 macro_rules! log {
@@ -70,13 +71,13 @@ pub struct ContextInner<App: ApplicationLayer> {
 
 fn parse_fragment_header<StorageError>(
     incoming_fragment: &[u8],
-) -> Result<(usize, usize, [u8; AES_GCM_IV_SIZE]), ReceiveError<StorageError>> {
+) -> Result<(usize, usize, [u8; AES_GCM_NONCE_SIZE]), ReceiveError<StorageError>> {
     let fragment_no = incoming_fragment[FRAGMENT_NO_IDX] as usize;
     let fragment_count = incoming_fragment[FRAGMENT_COUNT_IDX] as usize;
     if fragment_no >= fragment_count || fragment_count > MAX_FRAGMENTS {
         return Err(byzantine_fault!(FaultType::InvalidPacket, true));
     }
-    let mut nonce = [0u8; AES_GCM_IV_SIZE];
+    let mut nonce = [0u8; AES_GCM_NONCE_SIZE];
     nonce[2..].copy_from_slice(&incoming_fragment[PACKET_NONCE_START..HEADER_SIZE]);
     Ok((fragment_no, fragment_count, nonce))
 }
@@ -230,7 +231,8 @@ impl<App: ApplicationLayer> Context<App> {
             let session = ctx.session_map.read().unwrap().get(&kid_recv).map(|r| r.upgrade());
             if let Some(Some(session)) = session {
                 drop(session_map);
-                session.hk_recv.decrypt_in_place(
+                let state = session.state.read().unwrap();
+                state.hk_recv.decrypt_in_place(
                     (&mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
                         .try_into()
                         .unwrap(),
@@ -238,14 +240,17 @@ impl<App: ApplicationLayer> Context<App> {
 
                 let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
                 let (packet_type, incoming_counter) = from_nonce(&nonce);
+                if packet_type != PACKET_TYPE_DATA {
+                    log!(
+                        app,
+                        ReceivedRawFragment(packet_type, incoming_counter, fragment_no, fragment_count)
+                    );
+                }
 
                 {
                     //vrfy
-                    if packet_type != PACKET_TYPE_DATA {
-                        log!(app, ReceivedRawFragment(p, c, fragment_no, fragment_count));
-                    }
                     if packet_type == PACKET_TYPE_HANDSHAKE_RESPONSE {
-                        if !matches!(&session.state.read().unwrap().beta, ZetaAutomata::A1(_)) {
+                        if !matches!(&state.beta, ZetaAutomata::A1(_)) {
                             // A resent handshake response from Bob may have arrived out of order,
                             // after we already received one.
                             return Err(byzantine_fault!(OutOfSequence, false));
@@ -299,9 +304,12 @@ impl<App: ApplicationLayer> Context<App> {
                     } else {
                         std::slice::from_mut(&mut incoming_fragment_buf)
                     };
-                    receive_payload_in_place(&session, kid_recv, &nonce, fragments, output_buffer)?;
+
+                    receive_payload_in_place(&session, state, kid_recv, &nonce, fragments, output_buffer)?;
+
                     SessionEvent::Data
                 } else {
+                    drop(state);
                     let mut buffer = ArrayVec::<u8, HANDSHAKE_RESPONSE_SIZE>::new();
                     let assembled_packet = if fragment_count > 1 {
                         let idx = incoming_counter as usize % session.defrag.len();
@@ -424,13 +432,13 @@ impl<App: ApplicationLayer> Context<App> {
 
                     let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
                     let (packet_type, incoming_counter) = from_nonce(&nonce);
+                    log!(
+                        app,
+                        ReceivedRawFragment(packet_type, incoming_counter, fragment_no, fragment_count)
+                    );
 
                     {
                         //vrfy
-                        log!(
-                            app,
-                            ReceivedRawFragment(packet_type, incoming_counter, frag_no, frag_count)
-                        );
                         if packet_type != PACKET_TYPE_HANDSHAKE_COMPLETION || incoming_counter != 0 {
                             return Err(byzantine_fault!(InvalidPacket, true));
                         }
@@ -480,10 +488,10 @@ impl<App: ApplicationLayer> Context<App> {
         } else {
             let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
             let (packet_type, _c) = from_nonce(&nonce);
+            log!(app, ReceivedRawFragment(packet_type, _c, fragment_no, fragment_count));
 
             {
                 //vrfy
-                log!(app, ReceivedRawFragment(packet_type, _c, frag_no, frag_count));
                 if packet_type != PACKET_TYPE_HANDSHAKE_HELLO && packet_type != PACKET_TYPE_CHALLENGE {
                     return Err(byzantine_fault!(InvalidPacket, true));
                 }

From e7f0af7ab802876616b63c7af249ca1ef33a5b8b Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 11:11:15 -0400
Subject: [PATCH 23/50] renamed traits

---
 src/application.rs        |  8 ++++----
 src/challenge.rs          | 36 ++++++++++++++++++------------------
 src/crypto/aes.rs         |  4 ++--
 src/crypto/sha512.rs      |  4 ++--
 src/crypto_impl/sha512.rs |  4 ++--
 src/ratchet_state.rs      |  4 ++--
 src/symmetric_state.rs    | 14 +++++++-------
 src/zeta.rs               | 37 +++++++++++++++++++------------------
 src/zssp.rs               |  8 +++++---
 9 files changed, 61 insertions(+), 58 deletions(-)

diff --git a/src/application.rs b/src/application.rs
index 48dc269..dd48bae 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -102,11 +102,11 @@ pub trait ApplicationLayer: Sized {
     /// The implementation of AES-256 Encryption that ZSSP should use.
     ///
     /// FIPS compliance requires use of a FIPS certified implementation.
-    type PrpEnc: AesEnc;
+    type PrpEnc: Aes256Enc;
     /// The implementation of AES-256 Decryption that ZSSP should use.
     ///
     /// FIPS compliance requires use of a FIPS certified implementation.
-    type PrpDec: AesDec;
+    type PrpDec: Aes256Dec;
 
     type Aead: LowThroughputAesGcm;
     type AeadPool: HighThroughputAesGcmPool;
@@ -114,8 +114,8 @@ pub trait ApplicationLayer: Sized {
     /// The implementation of SHA-512 that ZSSP should use.
     ///
     /// FIPS compliance requires use of a FIPS certified implementation.
-    type Hash: HashSha512;
-    type HmacHash: HmacSha512;
+    type Hash: Sha512Hash;
+    type Hmac: Sha512Hmac;
     /// The implementation of P-384 public keys that ZSSP should use.
     ///
     /// FIPS compliance requires a FIPS certified implementation.
diff --git a/src/challenge.rs b/src/challenge.rs
index cc4de21..faabbce 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -14,14 +14,15 @@ pub struct ChallengeContext {
 }
 
 /// Corresponds to Algorithm 11 found in Section 5.
-pub fn gen_null_response<Rng: RngCore + CryptoRng>(rng: &mut Rng) -> [u8; CHALLENGE_SIZE] {
+pub fn gen_null_response(rng: &mut impl RngCore) -> [u8; CHALLENGE_SIZE] {
     let mut response = [0u8; CHALLENGE_SIZE];
     response[POW_START..].copy_from_slice(&rng.next_u64().to_be_bytes());
     response
 }
 /// Corresponds to Algorithm 13 found in Section 5.
-pub fn respond_to_challenge_in_place<Rng: RngCore + CryptoRng, Hash: HashSha512>(
-    rng: &mut Rng,
+pub fn respond_to_challenge_in_place(
+    rng: &mut impl RngCore,
+    hash: &mut impl Sha512Hash,
     challenge: &[u8; CHALLENGE_SIZE],
     pre_response: &mut [u8; CHALLENGE_SIZE],
 ) {
@@ -31,7 +32,7 @@ pub fn respond_to_challenge_in_place<Rng: RngCore + CryptoRng, Hash: HashSha512>
         let mut work_buf = [0u8; SHA512_HASH_SIZE];
         loop {
             pre_response[POW_START..].copy_from_slice(&pow.to_be_bytes());
-            if verify_pow::<Hash>(pre_response, &mut work_buf) {
+            if verify_pow(hash, pre_response, &mut work_buf) {
                 return;
             }
             pow = pow.wrapping_add(1);
@@ -50,16 +51,17 @@ impl ChallengeContext {
         }
     }
     /// Corresponds to Algorithm 12 found in Section 5.
-    pub fn process_hello<Hash: HashSha512>(
+    pub fn process_hello(
         &self,
+        hash: &mut impl Sha512Hash,
         addr: &impl std::hash::Hash,
         response: &[u8; CHALLENGE_SIZE],
     ) -> Result<(), [u8; CHALLENGE_SIZE]> {
         let c = u64::from_be_bytes(response[..COUNTER_SIZE].try_into().unwrap());
         let mut work_buf = [0u8; SHA512_HASH_SIZE];
         if self.antireplay_window.check(c)
-            && secure_eq(&response[COUNTER_SIZE..POW_START], &self.create_mac::<Hash>(c, addr))
-            && verify_pow::<Hash>(response, &mut work_buf)
+            && secure_eq(&response[COUNTER_SIZE..POW_START], &self.create_mac(hash, c, addr))
+            && verify_pow(hash, response, &mut work_buf)
         {
             self.antireplay_window.update(c);
             Ok(())
@@ -67,28 +69,27 @@ impl ChallengeContext {
             let mut challenge = [0u8; CHALLENGE_SIZE];
             let d = self.counter.fetch_add(1, Ordering::Relaxed);
             challenge[..COUNTER_SIZE].copy_from_slice(&d.to_be_bytes());
-            challenge[COUNTER_SIZE..POW_START].copy_from_slice(&self.create_mac::<Hash>(d, addr));
+            challenge[COUNTER_SIZE..POW_START].copy_from_slice(&self.create_mac(hash, d, addr));
             challenge[POW_START..].copy_from_slice(&response[POW_START..]);
             Err(challenge)
         }
     }
-    fn create_mac<Hash: HashSha512>(&self, c: u64, addr: &impl std::hash::Hash) -> [u8; MAC_SIZE] {
-        let mut h = Hash::new();
-        let mut hasher = ShaHasher(&mut h);
+    fn create_mac(&self, hash: &mut impl Sha512Hash, c: u64, addr: &impl std::hash::Hash) -> [u8; MAC_SIZE] {
+        let mut hasher = ShaHasher(hash);
         hasher.write(&c.to_be_bytes());
         addr.hash(&mut hasher);
         hasher.write(&self.salt);
         drop(hasher);
 
         let mut mac = [0u8; SHA512_HASH_SIZE];
-        h.finish_and_reset(&mut mac);
+        hash.finish_and_reset(&mut mac);
         mac[..MAC_SIZE].try_into().unwrap()
     }
 }
 
 /// Trick rust into letting us use a hasher that returns more than 64 bits.
-struct ShaHasher<'a, ShaImpl: HashSha512>(&'a mut ShaImpl);
-impl<'a, ShaImpl: HashSha512> Hasher for ShaHasher<'a, ShaImpl> {
+struct ShaHasher<'a, ShaImpl: Sha512Hash>(&'a mut ShaImpl);
+impl<'a, ShaImpl: Sha512Hash> Hasher for ShaHasher<'a, ShaImpl> {
     fn finish(&self) -> u64 {
         unimplemented!()
     }
@@ -99,10 +100,9 @@ impl<'a, ShaImpl: HashSha512> Hasher for ShaHasher<'a, ShaImpl> {
 
 /// Check if the proof of work attached to the first message contains the correct number of leading
 /// zeros.
-fn verify_pow<Hash: HashSha512>(response: &[u8], work_buf: &mut [u8; SHA512_HASH_SIZE]) -> bool {
-    let mut hasher = Hash::new();
-    hasher.update(response);
-    hasher.finish_and_reset(work_buf);
+fn verify_pow(hash: &mut impl Sha512Hash, response: &[u8], work_buf: &mut [u8; SHA512_HASH_SIZE]) -> bool {
+    hash.update(response);
+    hash.finish_and_reset(work_buf);
     let n = u32::from_be_bytes(work_buf[..4].try_into().unwrap());
     n.leading_zeros() >= DIFFICULTY
 }
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index 8368e08..a06b85d 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -10,7 +10,7 @@ pub const AES_GCM_NONCE_SIZE: usize = 12;
 /// algorithm is secure.
 ///
 /// Instances must securely delete their keys when dropped or reset.
-pub trait AesEnc: Send + Sync {
+pub trait Aes256Enc: Send + Sync {
     fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self;
 
     /// Change the encryption key to `key` so that all future encryption is performed with it.
@@ -26,7 +26,7 @@ pub trait AesEnc: Send + Sync {
 /// A trait for decrypting individual blocks of plaintext using AES-256.
 ///
 /// Instances must securely delete their keys when dropped or reset.
-pub trait AesDec: Send + Sync {
+pub trait Aes256Dec: Send + Sync {
     fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self;
 
     /// Change the decryption key to `key` so that all future decryption is performed with it.
diff --git a/src/crypto/sha512.rs b/src/crypto/sha512.rs
index 32a0a82..4e064d5 100644
--- a/src/crypto/sha512.rs
+++ b/src/crypto/sha512.rs
@@ -3,7 +3,7 @@
 pub const SHA512_HASH_SIZE: usize = 64;
 
 /// A SHA-512 implementation.
-pub trait HashSha512 {
+pub trait Sha512Hash {
     /// Create a new instance of SHA-512 for streaming data to.
     fn new() -> Self;
     /// Update the instance of SHA-512 with input `data`.
@@ -15,7 +15,7 @@ pub trait HashSha512 {
 
 /// Opaque HMAC-SHA-512 implementation.
 /// Does not need to be threadsafe.
-pub trait HmacSha512 {
+pub trait Sha512Hmac {
     /// Allocate space on the stack or heap for repeated Hmac invocations.
     ///
     /// Many FIPS compliant libraries, namely OpenSSL, require initializing an Hmac context on the
diff --git a/src/crypto_impl/sha512.rs b/src/crypto_impl/sha512.rs
index 10dc3b5..3b72b46 100644
--- a/src/crypto_impl/sha512.rs
+++ b/src/crypto_impl/sha512.rs
@@ -4,7 +4,7 @@ use sha2::{Digest, Sha512};
 use crate::crypto::*;
 
 pub type RustSha512 = Sha512;
-impl HashSha512 for RustSha512 {
+impl Sha512Hash for RustSha512 {
     fn new() -> Self {
         Digest::new()
     }
@@ -21,7 +21,7 @@ impl HashSha512 for RustSha512 {
 }
 
 pub struct RustHmac;
-impl HmacSha512 for RustHmac {
+impl Sha512Hmac for RustHmac {
     fn new() -> Self {
         RustHmac
     }
diff --git a/src/ratchet_state.rs b/src/ratchet_state.rs
index d90298b..72a4ca9 100644
--- a/src/ratchet_state.rs
+++ b/src/ratchet_state.rs
@@ -52,7 +52,7 @@ impl RatchetState {
             chain_len: 0,
         }
     }
-    pub fn new_from_otp<Hmac: HmacSha512>(otp: &[u8]) -> RatchetState {
+    pub fn new_from_otp<Hmac: Sha512Hmac>(otp: &[u8]) -> RatchetState {
         let mut buffer = ArrayVec::<u8, 23>::new();
         buffer.push(1);
         buffer.extend(*LABEL_OTP_TO_RATCHET);
@@ -102,7 +102,7 @@ impl RatchetStates {
     pub fn new_initial_states() -> Self {
         Self { state1: RatchetState::empty(), state2: None }
     }
-    pub fn new_otp_states<Hmac: HmacSha512>(otp: &[u8]) -> Self {
+    pub fn new_otp_states<Hmac: Sha512Hmac>(otp: &[u8]) -> Self {
         Self {
             state1: RatchetState::new_from_otp::<Hmac>(otp),
             state2: None,
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 6f23da2..6a58549 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -40,7 +40,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     /// Corresponds to Noise `HKDF`.
     fn kbkdf(
         &self,
-        hmac: &mut App::HmacHash,
+        hmac: &mut App::Hmac,
         input_key_material: &[u8],
         label: &[u8; 4],
         num_outputs: u16,
@@ -86,7 +86,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         }
     }
     /// Corresponds to Noise `MixKey`.
-    pub fn mix_key(&mut self, hmac: &mut App::HmacHash, input_key_material: &[u8]) {
+    pub fn mix_key(&mut self, hmac: &mut App::Hmac, input_key_material: &[u8]) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
         let mut temp_k = Zeroizing::new([0u8; HASHLEN]);
 
@@ -104,7 +104,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
     /// Corresponds to Noise `MixKey`.
-    pub fn mix_key_no_init(&mut self, hmac: &mut App::HmacHash, input_key_material: &[u8]) {
+    pub fn mix_key_no_init(&mut self, hmac: &mut App::Hmac, input_key_material: &[u8]) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
 
         self.kbkdf(hmac, input_key_material, LABEL_KBKDF_CHAIN, 2, &mut next_ck, None, None);
@@ -118,7 +118,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         hash.finish_and_reset(&mut self.h);
     }
     /// Corresponds to Noise `MixKeyAndHash`.
-    pub fn mix_key_and_hash(&mut self, hash: &mut App::Hash, hmac: &mut App::HmacHash, input_key_material: &[u8]) {
+    pub fn mix_key_and_hash(&mut self, hash: &mut App::Hash, hmac: &mut App::Hmac, input_key_material: &[u8]) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
         let mut temp_h = [0u8; HASHLEN];
         let mut temp_k = Zeroizing::new([0u8; HASHLEN]);
@@ -141,7 +141,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     pub fn mix_key_and_hash_no_init(
         &mut self,
         hash: &mut App::Hash,
-        hmac: &mut App::HmacHash,
+        hmac: &mut App::Hmac,
         input_key_material: &[u8],
     ) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
@@ -192,7 +192,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         is_auth
     }
     /// Corresponds to Noise `Split`.
-    pub fn split(self, hmac: &mut App::HmacHash, key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
+    pub fn split(self, hmac: &mut App::Hmac, key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
         self.kbkdf(hmac, &[], LABEL_KBKDF_CHAIN, 2, key1, Some(key2), None);
     }
     /// Get an additional symmetric key (ASK) that is a collision resistant hash of the transcript,
@@ -201,7 +201,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
     pub fn get_ask(
         &self,
-        hmac: &mut App::HmacHash,
+        hmac: &mut App::Hmac,
         label: &[u8; 4],
         key1: &mut [u8; HASHLEN],
         key2: &mut [u8; HASHLEN],
diff --git a/src/zeta.rs b/src/zeta.rs
index 3b71ec4..3819c25 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -46,7 +46,7 @@ pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
     (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
 }
 fn create_ratchet_state<App: ApplicationLayer>(
-    hmac: &mut App::HmacHash,
+    hmac: &mut App::Hmac,
     noise: &SymmetricState<App>,
     pre_chain_len: u64,
 ) -> RatchetState {
@@ -196,7 +196,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     fn write_e<const CAP: usize>(
         &mut self,
         hash: &mut App::Hash,
-        hmac: &mut App::HmacHash,
+        hmac: &mut App::Hmac,
         rng: &Mutex<App::Rng>,
         packet: &mut ArrayVec<u8, CAP>,
     ) -> App::KeyPair {
@@ -210,7 +210,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     fn read_e(
         &mut self,
         hash: &mut App::Hash,
-        hmac: &mut App::HmacHash,
+        hmac: &mut App::Hmac,
         i: &mut usize,
         packet: &[u8],
     ) -> Option<App::PublicKey> {
@@ -224,7 +224,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     fn write_e_no_init<const CAP: usize>(
         &mut self,
         hash: &mut App::Hash,
-        hmac: &mut App::HmacHash,
+        hmac: &mut App::Hmac,
         rng: &Mutex<App::Rng>,
         packet: &mut ArrayVec<u8, CAP>,
     ) -> App::KeyPair {
@@ -238,7 +238,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     fn read_e_no_init(
         &mut self,
         hash: &mut App::Hash,
-        hmac: &mut App::HmacHash,
+        hmac: &mut App::Hmac,
         i: &mut usize,
         packet: &[u8],
     ) -> Option<App::PublicKey> {
@@ -249,7 +249,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         *i = j;
         App::PublicKey::from_bytes((pub_key).try_into().unwrap())
     }
-    fn mix_dh(&mut self, hmac: &mut App::HmacHash, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
+    fn mix_dh(&mut self, hmac: &mut App::Hmac, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
         let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
         if secret.agree(&remote, &mut ecdh_secret) {
             self.mix_key(hmac, ecdh_secret.as_ref());
@@ -260,7 +260,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
     fn mix_dh_no_init(
         &mut self,
-        hmac: &mut App::HmacHash,
+        hmac: &mut App::Hmac,
         secret: &App::KeyPair,
         remote: &App::PublicKey,
     ) -> Option<()> {
@@ -301,7 +301,7 @@ fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_NONCE_SIZE]
 
 fn create_a1_state<App: ApplicationLayer>(
     hash: &mut App::Hash,
-    hmac: &mut App::HmacHash,
+    hmac: &mut App::Hmac,
     rng: &Mutex<App::Rng>,
     s_remote: &App::PublicKey,
     kid_recv: NonZeroU32,
@@ -376,7 +376,7 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     let kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
 
     let hash = &mut App::Hash::new();
-    let hmac = &mut App::HmacHash::new();
+    let hmac = &mut App::Hmac::new();
     let a1 = create_a1_state(
         hash,
         hmac,
@@ -449,8 +449,9 @@ pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
     let mut state = session.state.write().unwrap();
     if let ZetaAutomata::A1(a1) = &mut state.beta {
         let response_start = a1.x1.len() - CHALLENGE_SIZE;
-        respond_to_challenge_in_place::<App::Rng, App::Hash>(
+        respond_to_challenge_in_place(
             ctx.rng.lock().unwrap().deref_mut(),
+            &mut App::Hash::new(),
             challenge,
             (&mut a1.x1[response_start..]).try_into().unwrap(),
         );
@@ -460,6 +461,7 @@ pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
 pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     app: &App,
     ctx: &ContextInner<App>,
+    hash: &mut App::Hash,
     n: &[u8; AES_GCM_NONCE_SIZE],
     x1: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
@@ -476,8 +478,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     if &n[AES_GCM_NONCE_SIZE - 8..] != &x1[x1.len() - 8..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let hash = &mut App::Hash::new();
-    let hmac = &mut App::HmacHash::new();
+    let hmac = &mut App::Hmac::new();
     let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_XK);
     let mut i = 0;
     // Noise process prologue.
@@ -623,7 +624,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     let kex_lock = session.state_machine_lock.lock().unwrap();
     let state = session.state.read().unwrap();
     let hash = &mut App::Hash::new();
-    let hmac = &mut App::HmacHash::new();
+    let hmac = &mut App::Hmac::new();
 
     if Some(kid) != state.key_ref(true).recv.kid {
         return Err(byzantine_fault!(UnknownLocalKeyId, true));
@@ -842,7 +843,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(UnknownLocalKeyId, true));
     }
     let hash = &mut App::Hash::new();
-    let hmac = &mut App::HmacHash::new();
+    let hmac = &mut App::Hmac::new();
 
     let mut noise = zeta.noise.clone();
     let mut i = 0;
@@ -1212,7 +1213,7 @@ fn timeout_trans<App: ApplicationLayer>(
             let new_kid_recv = remap(ctx, session, &state);
 
             let hash = &mut App::Hash::new();
-            let hmac = &mut App::HmacHash::new();
+            let hmac = &mut App::Hmac::new();
             if let Some(a1) = create_a1_state(
                 hash,
                 hmac,
@@ -1259,7 +1260,7 @@ fn timeout_trans<App: ApplicationLayer>(
             //    -> psk, e, es, ss
             let mut noise = SymmetricState::initialize(PROTOCOL_NAME_NOISE_KK);
             let hash = &mut App::Hash::new();
-            let hmac = &mut App::HmacHash::new();
+            let hmac = &mut App::Hmac::new();
             let mut k1 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
             k1.extend([0u8; HEADER_SIZE]);
             // Noise process prologue.
@@ -1438,7 +1439,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         let mut i = 0;
         let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_KK);
         let hash = &mut App::Hash::new();
-        let hmac = &mut App::HmacHash::new();
+        let hmac = &mut App::Hmac::new();
         // Noise process prologue.
         noise.mix_hash(hash, &session.s_remote.to_bytes());
         noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
@@ -1591,7 +1592,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             let mut noise = noise.clone();
             let mut i = 0;
             let hash = &mut App::Hash::new();
-            let hmac = &mut App::HmacHash::new();
+            let hmac = &mut App::Hmac::new();
             // Process message pattern 2 e token.
             let e_remote = noise
                 .read_e(hash, hmac, &mut i, &k2)
diff --git a/src/zssp.rs b/src/zssp.rs
index 52e4361..78a7a30 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -85,7 +85,7 @@ fn parse_fragment_header<StorageError>(
 /// Fragments and sends the packet, destroying it in the process.
 ///
 /// Corresponds to the fragmentation algorithm described in Section 6.
-fn send_with_fragmentation<PrpEnc: AesEnc>(
+fn send_with_fragmentation<PrpEnc: Aes256Enc>(
     mut send: impl FnMut(&mut [u8]) -> bool,
     mtu: usize,
     headered_packet: &mut [u8],
@@ -533,11 +533,13 @@ impl<App: ApplicationLayer> Context<App> {
                     return Err(byzantine_fault!(InvalidPacket, true));
                 }
                 // Process recv challenge layer.
+                let hash = &mut App::Hash::new();
                 match app.incoming_session() {
                     IncomingSessionAction::Allow => {}
                     IncomingSessionAction::Challenge => {
                         let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
-                        let result = ctx.challenge.process_hello::<App::Hash>(
+                        let result = ctx.challenge.process_hello(
+                            hash,
                             remote_address,
                             (&assembled_packet[challenge_start..]).try_into().unwrap(),
                         );
@@ -564,7 +566,7 @@ impl<App: ApplicationLayer> Context<App> {
                 }
 
                 // Process recv zeta layer.
-                received_x1_trans(&app, ctx, &nonce, assembled_packet, |packet, hk_send| {
+                received_x1_trans(&app, ctx, hash, &nonce, assembled_packet, |packet, hk_send| {
                     send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
                 })?;
                 log!(app, X1IsAuthSentX2);

From a423f87554cd031ad63d25c7d74ecf3823a70e91 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 12:51:53 -0400
Subject: [PATCH 24/50] added openssl-sys

---
 Cargo.lock                   |  34 +++
 Cargo.toml                   |   1 +
 examples/basic_test.rs       | 398 +++++++++++++++++++++++++++++++++++
 src/application.rs           |   5 -
 src/crypto/aes.rs            |   8 +-
 src/crypto_impl/kyber1024.rs |  14 --
 src/crypto_impl/mod.rs       |   3 +
 src/crypto_impl/openssl.rs   | 284 +++++++++++++++++++++++++
 src/crypto_impl/p384_impl.rs |   8 +-
 src/crypto_impl/sha512.rs    |  10 +-
 src/lib.rs                   |  10 +-
 src/symmetric_state.rs       |  15 +-
 src/zeta.rs                  |  76 ++-----
 src/zssp.rs                  |  13 +-
 14 files changed, 766 insertions(+), 113 deletions(-)
 create mode 100644 examples/basic_test.rs
 create mode 100644 src/crypto_impl/openssl.rs

diff --git a/Cargo.lock b/Cargo.lock
index 81b8afa..50f595c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,6 +26,15 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "cc"
+version = "1.0.82"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "305fe645edc1442a0fa8b6726ba61d422798d37a52e12eaecf4b022ebbb88f01"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -176,6 +185,18 @@ version = "0.2.147"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
 
+[[package]]
+name = "openssl-sys"
+version = "0.9.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "866b5f16f90776b9bb8dc1e1802ac6f0513de3a7a7465867bfbc563dc737faac"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "p384"
 version = "0.13.0"
@@ -186,6 +207,12 @@ dependencies = [
  "primeorder",
 ]
 
+[[package]]
+name = "pkg-config"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
+
 [[package]]
 name = "pqc_kyber"
 version = "0.6.0"
@@ -249,6 +276,12 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "version_check"
 version = "0.9.4"
@@ -273,6 +306,7 @@ version = "0.0.3"
 dependencies = [
  "arrayvec",
  "hmac",
+ "openssl-sys",
  "p384",
  "pqc_kyber",
  "rand_core",
diff --git a/Cargo.toml b/Cargo.toml
index 9b02171..e291b16 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,6 +19,7 @@ pqc_kyber = { version = "0.6.0", default-features = false, features = ["kyber102
 p384 = { version = "0.13.0", default-features = false, features = ["ecdh"], optional = true }
 sha2 = { version = "0.10.7", default-features = false, optional = true }
 hmac = { version = "0.12.1", default-features = false, optional = true }
+openssl-sys = { version = "0.9.91", default-features = false }
 
 [features]
 default = ["debug", "p384", "hmac", "pqc_kyber"]
diff --git a/examples/basic_test.rs b/examples/basic_test.rs
new file mode 100644
index 0000000..71fde87
--- /dev/null
+++ b/examples/basic_test.rs
@@ -0,0 +1,398 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * (c) ZeroTier, Inc.
+ * https://www.zerotier.com/
+ */
+
+use std::collections::HashMap;
+use std::iter::ExactSizeIterator;
+use std::str::FromStr;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{mpsc, Arc, Mutex};
+use std::thread;
+use std::time::{Duration, Instant};
+
+use rand_core::OsRng;
+use rand_core::RngCore;
+
+use zssp::application::{
+    AcceptAction, ApplicationLayer, RatchetState, RatchetStates, RatchetUpdate, Settings, RATCHET_SIZE, IncomingSessionAction,
+};
+use zssp::crypto::P384KeyPair;
+use zssp::crypto_impl::*;
+use zssp::Session;
+use zssp::result::ReceiveError;
+
+const TEST_MTU: usize = 1500;
+
+struct TestApplication {
+    time: Instant,
+    name: &'static str,
+    ratchets: Mutex<Ratchets>,
+}
+
+struct Ratchets {
+    rf_map: HashMap<[u8; RATCHET_SIZE], RatchetState>,
+    peer_map: HashMap<u128, RatchetStates>,
+}
+impl Ratchets {
+    fn new() -> Self {
+        Self { rf_map: HashMap::new(), peer_map: HashMap::new() }
+    }
+}
+
+#[allow(unused)]
+impl ApplicationLayer for &TestApplication {
+    const SETTINGS: Settings = Settings {
+        initial_offer_timeout: Settings::INITIAL_OFFER_TIMEOUT_MS,
+        rekey_timeout: 60 * 1000,
+        rekey_after_time: 3000,
+        rekey_time_max_jitter: 1000,
+        rekey_after_key_uses: Settings::REKEY_AFTER_KEY_USES,
+        resend_time: 250,
+        fragment_assembly_timeout: Settings::FRAGMENT_ASSEMBLY_TIMEOUT_MS,
+    };
+
+    type Rng = OsRng;
+    type PrpEnc = Aes256OpenSSLEnc;
+    type PrpDec = Aes256OpenSSLDec;
+    type Aead = AesGcmOpenSSL;
+    type AeadPool = AesGcmOpenSSLPool;
+    type Hash = Sha512Crate;
+    type Hmac = HmacSha512Crate;
+    type PublicKey = P384CratePublicKey;
+    type KeyPair = P384CrateKeyPair;
+    type Kem = RustKyber1024PrivateKey;
+
+    type StorageError = std::convert::Infallible;
+    type SessionData = u128;
+
+    type IncomingPacketBuffer = Vec<u8>;
+
+
+    fn incoming_session(&self) -> IncomingSessionAction {
+        IncomingSessionAction::Allow
+    }
+
+    fn hello_requires_recognized_ratchet(&self) -> bool {
+        false
+    }
+
+    fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>) -> bool {
+        true
+    }
+
+    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self> {
+        AcceptAction {
+            session_data: Some(1),
+            responder_disallows_downgrade: true,
+            responder_silently_rejects: false,
+        }
+    }
+
+    fn restore_by_fingerprint(
+        &self,
+        ratchet_fingerprint: &[u8; RATCHET_SIZE],
+    ) -> Result<Option<RatchetState>, Self::StorageError> {
+        let ratchets = self.ratchets.lock().unwrap();
+        Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
+    }
+
+    fn restore_by_identity(
+        &self,
+        remote_static_key: &Self::PublicKey,
+        session_data: &Self::SessionData,
+    ) -> Result<Option<RatchetStates>, Self::StorageError> {
+        let ratchets = self.ratchets.lock().unwrap();
+        Ok(ratchets.peer_map.get(session_data).cloned())
+    }
+
+    fn save_ratchet_state(
+        &self,
+        remote_static_key: &Self::PublicKey,
+        session_data: &Self::SessionData,
+        update_data: RatchetUpdate<'_>,
+    ) -> Result<(), Self::StorageError> {
+        let mut ratchets = self.ratchets.lock().unwrap();
+        ratchets.peer_map.insert(*session_data, update_data.to_states());
+
+        if let Some(rf) = update_data.added_fingerprint() {
+            ratchets.rf_map.insert(*rf, update_data.state1.clone());
+            println!("[{}] new ratchet #{}", self.name, update_data.state1.chain_len);
+        }
+        if let Some(rf) = update_data.deleted_fingerprint1() {
+            ratchets.rf_map.remove(rf);
+        }
+        if let Some(rf) = update_data.deleted_fingerprint2() {
+            ratchets.rf_map.remove(rf);
+        }
+        Ok(())
+    }
+
+    fn time(&self) -> i64 {
+        self.time.elapsed().as_millis() as i64
+    }
+
+    fn event_log(&self, event: zssp::LogEvent<Self>) {
+        println!(">[{}] {:?}", self.name, event);
+    }
+}
+
+fn alice_main(
+    run: &AtomicBool,
+    packet_success_rate: u32,
+    alice_app: &TestApplication,
+    alice_out: mpsc::SyncSender<Vec<u8>>,
+    alice_in: mpsc::Receiver<Vec<u8>>,
+    recursive_out: mpsc::SyncSender<Vec<u8>>,
+    alice_keypair: P384CrateKeyPair,
+    bob_pubkey: P384CratePublicKey,
+) {
+    let startup_time = std::time::Instant::now();
+    let context = zssp::Context::<&TestApplication>::new(alice_keypair, OsRng);
+    let mut next_service = startup_time.elapsed().as_millis() as i64 + 500;
+    let test_data = [1u8; TEST_MTU * 10];
+    let mut up = false;
+    let mut alice_session = None;
+
+    while run.load(Ordering::Relaxed) {
+        if alice_session.is_none() {
+            up = false;
+            alice_session = Some(
+                context
+                    .open(
+                        alice_app,
+                        |b| alice_out.send(b.to_vec()).is_ok(),
+                        TEST_MTU,
+                        bob_pubkey.clone(),
+                        0,
+                        &[],
+                    )
+                    .unwrap(),
+            );
+            println!("[alice] opening session");
+        }
+        let current_time = startup_time.elapsed().as_millis() as i64;
+        loop {
+            let pkt = alice_in.try_recv();
+            if let Ok(pkt) = pkt {
+                if OsRng.next_u32() <= packet_success_rate {
+                    use zssp::result::ReceiveOk::*;
+                    use zssp::result::SessionEvent::*;
+                    let mut output_data = Vec::new();
+                    match context.receive(
+                        alice_app,
+                        |b| alice_out.send(b.to_vec()).is_ok(),
+                        TEST_MTU,
+                        |_| Some((|b: &mut [u8]| alice_out.send(b.to_vec()).is_ok(), TEST_MTU)),
+                        &0,
+                        pkt,
+                        &mut output_data
+                    ) {
+                        Ok(Unassociated) => {
+                            //println!("[alice] ok");
+                        }
+                        Ok(Session(_, event)) => match event {
+                            Established => {
+                                up = true;
+                            }
+                            Data => {
+                                assert!(!output_data.is_empty());
+                                //println!("[alice] received {}", data.len());
+                            }
+                            NewSession => panic!(),
+                            Rejected => panic!(),
+                            Control => (),
+                        },
+                        Err(e) => {
+                            println!("[alice] ERROR {:?}", e);
+                            if let ReceiveError::ByzantineFault { unnatural, .. } = e {
+                                assert!(!unnatural)
+                            }
+                        }
+                    }
+                } else if OsRng.next_u32() | 1 > 0 {
+                    let _ = recursive_out.send(pkt);
+                }
+            } else {
+                break;
+            }
+        }
+
+        if up {
+            context
+                .send(
+                    alice_session.as_ref().unwrap(),
+                    |b| alice_out.send(b.to_vec()).is_ok(),
+                    &mut [0u8; TEST_MTU],
+                    &test_data[..1400 + ((OsRng.next_u64() as usize) % (test_data.len() - 1400))],
+                )
+                .unwrap();
+        } else {
+            thread::sleep(Duration::from_millis(10));
+        }
+        // TODO: we need to more comprehensively test if re-opening the session works
+        if OsRng.next_u32() <= ((u32::MAX as f64) * 0.000005) as u32 {
+            alice_session = None;
+        }
+
+        if current_time >= next_service {
+            next_service =
+                current_time + context.service(alice_app, |_| Some((|b: &mut [u8]| alice_out.send(b.to_vec()).is_ok(), TEST_MTU)));
+        }
+    }
+}
+
+fn bob_main(
+    run: &AtomicBool,
+    packet_success_rate: u32,
+    bob_app: &TestApplication,
+    bob_out: mpsc::SyncSender<Vec<u8>>,
+    bob_in: mpsc::Receiver<Vec<u8>>,
+    recursive_out: mpsc::SyncSender<Vec<u8>>,
+    bob_keypair: P384CrateKeyPair,
+) {
+    let startup_time = std::time::Instant::now();
+    let context = zssp::Context::<&TestApplication>::new(bob_keypair, OsRng);
+    let mut last_speed_metric = startup_time.elapsed().as_millis() as i64;
+    let mut next_service = last_speed_metric + 500;
+    let mut transferred = 0u64;
+
+    let mut bob_session = None;
+
+    while run.load(Ordering::Relaxed) {
+        let pkt = bob_in.recv_timeout(Duration::from_millis(100));
+        let current_time = startup_time.elapsed().as_millis() as i64;
+
+        if let Ok(pkt) = pkt {
+            if OsRng.next_u32() <= packet_success_rate {
+                use zssp::result::ReceiveOk::*;
+                use zssp::result::SessionEvent::*;
+                let mut output_data = Vec::new();
+                match context.receive(
+                    bob_app,
+                    |b| bob_out.send(b.to_vec()).is_ok(),
+                    TEST_MTU,
+                    |_| Some((|b: &mut [u8]| bob_out.send(b.to_vec()).is_ok(), TEST_MTU)),
+                    &0,
+                    pkt,
+                    &mut output_data
+                ) {
+                    Ok(Unassociated) => {}
+                    Ok(Session(s, event)) => match event {
+                        NewSession => {
+                            println!("[bob] new session, took {}s", current_time as f32 / 1000.0);
+                            let _ = bob_session.replace(s);
+                        }
+                        Data => {
+                            assert!(!output_data.is_empty());
+                            //println!("[bob] received {}", output_data.len());
+                            transferred += output_data.len() as u64 * 2; // *2 because we are also sending this many bytes back
+                            context.send(&s, |b| bob_out.send(b.to_vec()).is_ok(), &mut [0u8; TEST_MTU], &output_data).unwrap();
+                        }
+                        Established => panic!(),
+                        Rejected => panic!(),
+                        Control => (),
+                    },
+                    Err(e) => {
+                        println!("[bob] ERROR {:?}", e);
+                        if let ReceiveError::ByzantineFault { unnatural, .. } = e {
+                            assert!(!unnatural)
+                        }
+                    }
+                }
+            } else if OsRng.next_u32() | 1 > 0 {
+                let _ = recursive_out.try_send(pkt);
+            }
+        }
+
+        let speed_metric_elapsed = current_time - last_speed_metric;
+        if speed_metric_elapsed >= 10000 {
+            last_speed_metric = current_time;
+            println!(
+                "[bob] throughput: {} MiB/sec (combined input and output)",
+                ((transferred as f64) / 1048576.0) / ((speed_metric_elapsed as f64) / 1000.0)
+            );
+            transferred = 0;
+        }
+
+        if current_time >= next_service {
+            next_service = current_time + context.service(bob_app, |_| Some((|b: &mut [u8]| bob_out.send(b.to_vec()).is_ok(), TEST_MTU)));
+        }
+    }
+}
+
+fn core(time: u64, packet_success_rate: u32) {
+    let run = &AtomicBool::new(true);
+
+    let alice_keypair = P384CrateKeyPair::generate(&mut OsRng);
+    let alice_app = TestApplication {
+        time: Instant::now(),
+        name: "alice",
+        ratchets: Mutex::new(Ratchets::new()),
+    };
+    let bob_keypair = P384CrateKeyPair::generate(&mut OsRng);
+    let bob_pubkey = bob_keypair.public_key();
+    let bob_app = TestApplication {
+        time: Instant::now(),
+        name: "bob",
+        ratchets: Mutex::new(Ratchets::new()),
+    };
+
+    let (alice_out, bob_in) = mpsc::sync_channel::<Vec<u8>>(256);
+    let (bob_out, alice_in) = mpsc::sync_channel::<Vec<u8>>(256);
+
+    thread::scope(|ts| {
+        {
+            let alice_out = alice_out.clone();
+            let bob_out = bob_out.clone();
+            ts.spawn(move || {
+                alice_main(
+                    run,
+                    packet_success_rate,
+                    &alice_app,
+                    alice_out,
+                    alice_in,
+                    bob_out,
+                    alice_keypair,
+                    bob_pubkey,
+                )
+            });
+        }
+        ts.spawn(move || {
+            bob_main(
+                run,
+                packet_success_rate,
+                &bob_app,
+                bob_out,
+                bob_in,
+                alice_out,
+                bob_keypair,
+            )
+        });
+
+        thread::sleep(Duration::from_secs(time));
+
+        run.store(false, Ordering::SeqCst);
+        println!("finished");
+    });
+}
+
+fn main() {
+    let args = std::env::args();
+    let packet_success_rate = if args.len() <= 1 {
+        let default_success_rate = 1.0;
+        ((u32::MAX as f64) * default_success_rate) as u32
+    } else {
+        ((u32::MAX as f64) * f64::from_str(args.last().unwrap().as_str()).unwrap()) as u32
+    };
+
+    core(60 * 60, packet_success_rate)
+}
+
+#[test]
+fn test_main() {
+    core(2, u32::MAX / 2)
+}
diff --git a/src/application.rs b/src/application.rs
index dd48bae..d05aeb8 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -2,7 +2,6 @@ use rand_core::{CryptoRng, RngCore};
 use std::sync::Arc;
 
 use crate::crypto::*;
-use crate::ratchet_state::RatchetState;
 use crate::zeta::Session;
 
 pub use crate::proto::RATCHET_SIZE;
@@ -145,10 +144,6 @@ pub trait ApplicationLayer: Sized {
     /// hold these for a short period of time when assembling fragmented packets on the receive
     /// path.
     type IncomingPacketBuffer: AsRef<[u8]> + AsMut<[u8]>;
-    /// Data type for giving ZSSP temporary ownership of a buffer containing the local party's
-    /// identity.
-    /// It will be dropped as soon as the session is established.
-    type LocalIdentityBlob: AsRef<[u8]>;
 
     /// Should return the current time in milliseconds. Does not have to be monotonic, nor synced
     /// with remote peers (although both of these properties would help reliability slightly).
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index a06b85d..9935564 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -62,21 +62,21 @@ pub trait HighThroughputAesGcmPool: Send + Sync {
 
     fn new(encrypt_key: &[u8; AES_256_KEY_SIZE], decrypt_key: &[u8; AES_256_KEY_SIZE]) -> Self;
 
-    fn start_enc<'a>(&'a self, iv: &[u8; AES_GCM_NONCE_SIZE]) -> Self::EncContext<'a>;
-    fn start_dec<'a>(&'a self, iv: &[u8; AES_GCM_NONCE_SIZE]) -> Self::DecContext<'a>;
+    fn start_enc<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> Self::EncContext<'a>;
+    fn start_dec<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> Self::DecContext<'a>;
 }
 
 pub trait LowThroughputAesGcm {
     fn encrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
-        iv: &[u8; AES_GCM_NONCE_SIZE],
+        nonce: &[u8; AES_GCM_NONCE_SIZE],
         aad: &[u8],
         data: &mut [u8],
     ) -> [u8; AES_GCM_TAG_SIZE];
     #[must_use]
     fn decrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
-        iv: &[u8; AES_GCM_NONCE_SIZE],
+        nonce: &[u8; AES_GCM_NONCE_SIZE],
         aad: &[u8],
         data: &mut [u8],
         tag: &[u8; AES_GCM_TAG_SIZE],
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index d2db360..feffd5f 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -35,17 +35,3 @@ impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for RustKyber1024Private
         }
     }
 }
-
-//impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for RustKyber1024PrivateKey {
-//    fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
-//    }
-
-//    fn encapsulate(
-//        rng: &mut Rng,
-//        public_key: &[u8; KYBER_PUBLIC_KEY_SIZE],
-//    ) -> Option<([u8; KYBER_CIPHERTEXT_SIZE], [u8; KYBER_PLAINTEXT_SIZE])> {
-//    }
-
-//    fn decapsulate(&self, ciphertext: &[u8; KYBER_CIPHERTEXT_SIZE]) -> Option<[u8; KYBER_PLAINTEXT_SIZE]> {
-//    }
-//}
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
index e24f28d..d414a06 100644
--- a/src/crypto_impl/mod.rs
+++ b/src/crypto_impl/mod.rs
@@ -11,6 +11,9 @@ mod sha512;
 #[cfg(feature = "sha2")]
 pub use sha512::*;
 
+mod openssl;
+pub use openssl::*;
+
 #[cfg(feature = "hmac")]
 pub use hmac;
 #[cfg(feature = "p384")]
diff --git a/src/crypto_impl/openssl.rs b/src/crypto_impl/openssl.rs
new file mode 100644
index 0000000..fb17bf9
--- /dev/null
+++ b/src/crypto_impl/openssl.rs
@@ -0,0 +1,284 @@
+use std::{
+    ptr::{self, NonNull},
+    sync::Mutex,
+};
+
+use openssl_sys::*;
+use zeroize::Zeroizing;
+
+use crate::crypto::*;
+
+struct CipherCtx(NonNull<openssl_sys::EVP_CIPHER_CTX>);
+impl Drop for CipherCtx {
+    fn drop(&mut self) {
+        unsafe {
+            EVP_CIPHER_CTX_free(self.0.as_ptr());
+        }
+    }
+}
+impl CipherCtx {
+    /// Creates a new context.
+    pub fn new() -> Option<Self> {
+        unsafe { Some(CipherCtx(NonNull::new(EVP_CIPHER_CTX_new())?)) }
+    }
+
+    pub unsafe fn cipher_init<const ENCRYPT: bool>(
+        &self,
+        t: *const openssl_sys::EVP_CIPHER,
+        key: *const u8,
+        iv: *const u8,
+    ) -> bool {
+        let evp_f = if ENCRYPT {
+            EVP_EncryptInit_ex
+        } else {
+            EVP_DecryptInit_ex
+        };
+
+        // OpenSSL will usually leak a static amount of memory per cipher given here.
+        evp_f(self.0.as_ptr(), t, ptr::null_mut(), key, iv) > 0
+    }
+
+    pub unsafe fn update<const ENCRYPT: bool>(&self, input: &[u8], output: *mut u8) -> bool {
+        let evp_f = if ENCRYPT {
+            EVP_EncryptUpdate
+        } else {
+            EVP_DecryptUpdate
+        };
+
+        let mut outlen = 0;
+
+        evp_f(
+            self.0.as_ptr(),
+            output,
+            &mut outlen,
+            input.as_ptr(),
+            input.len() as c_int,
+        ) > 0
+    }
+
+    pub unsafe fn finalize<const ENCRYPT: bool>(&self) -> bool {
+        let evp_f = if ENCRYPT {
+            EVP_EncryptFinal_ex
+        } else {
+            EVP_DecryptFinal_ex
+        };
+        let mut outl = 0;
+
+        evp_f(self.0.as_ptr(), ptr::null_mut(), &mut outl) > 0
+    }
+
+    pub unsafe fn get_tag(&self, tag: &mut [u8]) -> bool {
+        EVP_CIPHER_CTX_ctrl(
+            self.0.as_ptr(),
+            openssl_sys::EVP_CTRL_GCM_GET_TAG,
+            tag.len() as c_int,
+            tag.as_mut_ptr() as *mut _,
+        ) > 0
+    }
+
+    /// Sets the authentication tag for verification during decryption.
+    #[allow(unused)]
+    pub unsafe fn set_tag(&self, tag: &[u8]) -> bool {
+        EVP_CIPHER_CTX_ctrl(
+            self.0.as_ptr(),
+            openssl_sys::EVP_CTRL_GCM_SET_TAG,
+            tag.len() as c_int,
+            tag.as_ptr() as *mut _,
+        ) > 0
+    }
+    pub fn as_ptr(&self) -> *mut openssl_sys::EVP_CIPHER_CTX {
+        self.0.as_ptr()
+    }
+}
+
+pub struct Aes256OpenSSLEnc(Mutex<CipherCtx>);
+unsafe impl Send for Aes256OpenSSLEnc {}
+unsafe impl Sync for Aes256OpenSSLEnc {}
+
+impl Aes256Enc for Aes256OpenSSLEnc {
+    fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self {
+        let ctx = CipherCtx::new().unwrap();
+        unsafe {
+            let t = openssl_sys::EVP_aes_256_ecb();
+            assert!(ctx.cipher_init::<true>(t, key.as_ptr(), ptr::null()));
+            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+        }
+        Self(Mutex::new(ctx))
+    }
+
+    fn reset(&mut self, key: &[u8; AES_256_KEY_SIZE]) {
+        let ctx = self.0.lock().unwrap();
+        unsafe {
+            let t = openssl_sys::EVP_aes_256_ecb();
+            assert!(ctx.cipher_init::<true>(t, key.as_ptr(), ptr::null()));
+            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+        }
+    }
+
+    fn encrypt_in_place(&self, block: &mut [u8; AES_256_BLOCK_SIZE]) {
+        let ptr = block.as_mut_ptr();
+        let ctx = self.0.lock().unwrap();
+        unsafe { assert!(ctx.update::<true>(block, ptr)) }
+    }
+}
+pub struct Aes256OpenSSLDec(Mutex<CipherCtx>);
+unsafe impl Send for Aes256OpenSSLDec {}
+unsafe impl Sync for Aes256OpenSSLDec {}
+
+impl Aes256Dec for Aes256OpenSSLDec {
+    fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self {
+        let ctx = CipherCtx::new().unwrap();
+        unsafe {
+            let t = openssl_sys::EVP_aes_256_ecb();
+            assert!(ctx.cipher_init::<false>(t, key.as_ptr(), ptr::null()));
+            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+        }
+        Self(Mutex::new(ctx))
+    }
+
+    fn reset(&mut self, key: &[u8; AES_256_KEY_SIZE]) {
+        let ctx = self.0.lock().unwrap();
+        unsafe {
+            let t = openssl_sys::EVP_aes_256_ecb();
+            assert!(ctx.cipher_init::<false>(t, key.as_ptr(), ptr::null()));
+            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+        }
+    }
+
+    fn decrypt_in_place(&self, block: &mut [u8; AES_256_BLOCK_SIZE]) {
+        let ptr = block.as_mut_ptr();
+        let ctx = self.0.lock().unwrap();
+        unsafe { assert!(ctx.update::<false>(block, ptr)) }
+    }
+}
+
+pub struct AesGcmOpenSSLEnc(CipherCtx);
+impl AesGcmEncContext for AesGcmOpenSSLEnc {
+    fn encrypt(&mut self, input: &[u8], output: &mut [u8]) {
+        unsafe { assert!(self.0.update::<true>(input, output.as_mut_ptr())) };
+    }
+
+    fn finish(&mut self) -> [u8; AES_GCM_TAG_SIZE] {
+        let mut output = [0u8; AES_GCM_TAG_SIZE];
+        unsafe {
+            assert!(self.0.finalize::<true>());
+            assert!(self.0.get_tag(&mut output));
+        }
+        output
+    }
+}
+
+pub struct AesGcmOpenSSLDec(CipherCtx);
+impl AesGcmDecContext for AesGcmOpenSSLDec {
+    fn decrypt_in_place(&mut self, data: &mut [u8]) {
+        let p = data.as_mut_ptr();
+        unsafe { assert!(self.0.update::<false>(data, p)) };
+    }
+
+    fn finish(&mut self, tag: &[u8; AES_GCM_TAG_SIZE]) -> bool {
+        unsafe { self.0.set_tag(tag) && self.0.finalize::<false>() }
+    }
+}
+
+pub struct AesGcmOpenSSLPool(Zeroizing<[u8; AES_256_KEY_SIZE]>, Zeroizing<[u8; AES_256_KEY_SIZE]>);
+impl HighThroughputAesGcmPool for AesGcmOpenSSLPool {
+    type EncContext<'a> = AesGcmOpenSSLEnc;
+
+    type DecContext<'a> = AesGcmOpenSSLDec;
+
+    fn new(encrypt_key: &[u8; AES_256_KEY_SIZE], decrypt_key: &[u8; AES_256_KEY_SIZE]) -> Self {
+        AesGcmOpenSSLPool(Zeroizing::new(*encrypt_key), Zeroizing::new(*decrypt_key))
+    }
+
+    fn start_enc<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> AesGcmOpenSSLEnc {
+        let ctx = CipherCtx::new().unwrap();
+        unsafe {
+            let t = openssl_sys::EVP_aes_256_gcm();
+            assert!(ctx.cipher_init::<true>(t, self.0.as_ptr(), nonce.as_ptr()));
+            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+        }
+        AesGcmOpenSSLEnc(ctx)
+    }
+
+    fn start_dec<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> AesGcmOpenSSLDec {
+        let ctx = CipherCtx::new().unwrap();
+        unsafe {
+            let t = openssl_sys::EVP_aes_256_gcm();
+            assert!(ctx.cipher_init::<false>(t, self.0.as_ptr(), nonce.as_ptr()));
+            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+        }
+        AesGcmOpenSSLDec(ctx)
+    }
+}
+
+pub struct AesGcmOpenSSL;
+impl LowThroughputAesGcm for AesGcmOpenSSL {
+    fn encrypt_in_place(
+        key: &[u8; AES_256_KEY_SIZE],
+        nonce: &[u8; AES_GCM_NONCE_SIZE],
+        aad: &[u8],
+        data: &mut [u8],
+    ) -> [u8; AES_GCM_TAG_SIZE] {
+        let mut output = [0u8; AES_GCM_TAG_SIZE];
+        let ctx = CipherCtx::new().unwrap();
+        unsafe {
+            let t = openssl_sys::EVP_aes_256_gcm();
+            assert!(ctx.cipher_init::<true>(t, key.as_ptr(), nonce.as_ptr()));
+            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+
+            assert!(ctx.update::<true>(aad, ptr::null_mut()));
+            let p = data.as_mut_ptr();
+            assert!(ctx.update::<true>(data, p));
+
+            assert!(ctx.finalize::<true>());
+            assert!(ctx.get_tag(&mut output));
+        }
+        output
+    }
+
+    fn decrypt_in_place(
+        key: &[u8; AES_256_KEY_SIZE],
+        nonce: &[u8; AES_GCM_NONCE_SIZE],
+        aad: &[u8],
+        data: &mut [u8],
+        tag: &[u8; AES_GCM_TAG_SIZE],
+    ) -> bool {
+        let ctx = CipherCtx::new().unwrap();
+        unsafe {
+            let t = openssl_sys::EVP_aes_256_gcm();
+            assert!(ctx.cipher_init::<true>(t, key.as_ptr(), nonce.as_ptr()));
+            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+
+            assert!(ctx.update::<true>(aad, ptr::null_mut()));
+            let p = data.as_mut_ptr();
+            assert!(ctx.update::<true>(data, p));
+
+            ctx.set_tag(tag) && ctx.finalize::<false>()
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn aes_128_ecb() {
+        let key = [1u8; 16];
+        let ctx = CipherCtx::new().unwrap();
+        unsafe {
+            assert!(ctx.cipher_init::<true>(openssl_sys::EVP_aes_128_ecb(), key.as_ptr(), ptr::null()));
+            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+            assert_eq!(openssl_sys::EVP_CIPHER_CTX_get_block_size(ctx.as_ptr()) as usize, 16);
+
+            let origin = [2u8; 16];
+            let mut val = origin;
+            let p = val.as_mut_ptr();
+
+            assert!(ctx.update::<true>(&val, p));
+            assert!(ctx.cipher_init::<false>(ptr::null(), key.as_ptr(), ptr::null()));
+            assert!(ctx.update::<false>(&val, p));
+
+            assert_eq!(val, origin);
+        }
+    }
+}
diff --git a/src/crypto_impl/p384_impl.rs b/src/crypto_impl/p384_impl.rs
index d65028a..77c0938 100644
--- a/src/crypto_impl/p384_impl.rs
+++ b/src/crypto_impl/p384_impl.rs
@@ -3,8 +3,8 @@ use rand_core::{CryptoRng, RngCore};
 
 use crate::crypto::*;
 
-pub type RustP384PublicKey = PublicKey;
-impl P384PublicKey for PublicKey {
+pub type P384CratePublicKey = PublicKey;
+impl P384PublicKey for P384CratePublicKey {
     fn from_bytes(raw_key: &[u8; P384_PUBLIC_KEY_SIZE]) -> Option<Self> {
         PublicKey::from_sec1_bytes(raw_key).ok()
     }
@@ -15,8 +15,8 @@ impl P384PublicKey for PublicKey {
     }
 }
 
-pub type RustP384KeyPair = EphemeralSecret;
-impl<Rng: RngCore + CryptoRng> P384KeyPair<Rng> for RustP384KeyPair {
+pub type P384CrateKeyPair = EphemeralSecret;
+impl<Rng: RngCore + CryptoRng> P384KeyPair<Rng> for P384CrateKeyPair {
     type PublicKey = PublicKey;
 
     fn generate(rng: &mut Rng) -> Self {
diff --git a/src/crypto_impl/sha512.rs b/src/crypto_impl/sha512.rs
index 3b72b46..ba932f8 100644
--- a/src/crypto_impl/sha512.rs
+++ b/src/crypto_impl/sha512.rs
@@ -3,8 +3,8 @@ use sha2::{Digest, Sha512};
 
 use crate::crypto::*;
 
-pub type RustSha512 = Sha512;
-impl Sha512Hash for RustSha512 {
+pub type Sha512Crate = Sha512;
+impl Sha512Hash for Sha512Crate {
     fn new() -> Self {
         Digest::new()
     }
@@ -20,10 +20,10 @@ impl Sha512Hash for RustSha512 {
     }
 }
 
-pub struct RustHmac;
-impl Sha512Hmac for RustHmac {
+pub struct HmacSha512Crate;
+impl Sha512Hmac for HmacSha512Crate {
     fn new() -> Self {
-        RustHmac
+        HmacSha512Crate
     }
 
     fn hash(&mut self, key: &[u8], full_input: &[u8], output: &mut [u8; SHA512_HASH_SIZE]) {
diff --git a/src/lib.rs b/src/lib.rs
index 36c2fcd..626e58c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -20,15 +20,17 @@ mod log_event;
 pub use log_event::*;
 
 pub mod proto;
-pub mod ratchet_state;
+mod ratchet_state;
 pub mod result;
 mod symmetric_state;
-pub mod zeta;
-pub mod zssp;
+mod zeta;
+mod zssp;
 
+pub use zeta::*;
+pub use zssp::*;
 //pub mod error;
 //pub use crate::applicationlayer::ApplicationLayer;
 //pub use crate::log_event::LogEvent;
-//pub use crate::proto::{MAX_IDENTITY_BLOB_SIZE, MIN_PACKET_SIZE, MIN_TRANSPORT_MTU, RATCHET_SIZE};
+//pub use crate::proto::{IDENTITY_MAX_SIZE, MIN_PACKET_SIZE, MIN_TRANSPORT_MTU};
 //pub use crate::ratchet_state::RatchetState;
 //pub use crate::zssp::{Context, ContextInner, IncomingSessionAction, ReceiveResult, Session, SessionEvent};
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 6a58549..71cf4d0 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -138,12 +138,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
     /// Corresponds to Noise `MixKeyAndHash`.
-    pub fn mix_key_and_hash_no_init(
-        &mut self,
-        hash: &mut App::Hash,
-        hmac: &mut App::Hmac,
-        input_key_material: &[u8],
-    ) {
+    pub fn mix_key_and_hash_no_init(&mut self, hash: &mut App::Hash, hmac: &mut App::Hmac, input_key_material: &[u8]) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
         let mut temp_h = [0u8; HASHLEN];
 
@@ -199,13 +194,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     /// is forward secrect and is cryptographically independent from all other produced keys.
     /// Based on Noise's unstable ASK mechanism, using KBKDF instead of HKDF.
     /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
-    pub fn get_ask(
-        &self,
-        hmac: &mut App::Hmac,
-        label: &[u8; 4],
-        key1: &mut [u8; HASHLEN],
-        key2: &mut [u8; HASHLEN],
-    ) {
+    pub fn get_ask(&self, hmac: &mut App::Hmac, label: &[u8; 4], key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
         self.kbkdf(hmac, &self.h, label, 2, key1, Some(key2), None);
     }
     /// Used for internally debugging a key exchange.
diff --git a/src/zeta.rs b/src/zeta.rs
index 3819c25..07f7c74 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -64,13 +64,13 @@ fn get_counter<App: ApplicationLayer>(session: &Session<App>, state: &MutableSta
         None
     } else {
         let c = session.send_counter.fetch_add(1, Ordering::Relaxed);
+        if c > THREAD_SAFE_COUNTER_HARD_EXPIRE {
+            session.session_has_expired.store(true, Ordering::SeqCst);
+        }
         if c > state.key_creation_counter + EXPIRE_AFTER_USES {
             session.session_has_expired.store(true, Ordering::SeqCst);
             return None;
         }
-        if c > THREAD_SAFE_COUNTER_HARD_EXPIRE {
-            session.session_has_expired.store(true, Ordering::SeqCst);
-        }
         Some((c, c > state.key_creation_counter + App::SETTINGS.rekey_after_key_uses))
     }
 }
@@ -258,12 +258,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
             None
         }
     }
-    fn mix_dh_no_init(
-        &mut self,
-        hmac: &mut App::Hmac,
-        secret: &App::KeyPair,
-        remote: &App::PublicKey,
-    ) -> Option<()> {
+    fn mix_dh_no_init(&mut self, hmac: &mut App::Hmac, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
         let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
         if secret.agree(&remote, &mut ecdh_secret) {
             self.mix_key_no_init(hmac, ecdh_secret.as_ref());
@@ -1765,20 +1760,15 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
 
-    let is_other = if Some(kid) == state.key_ref(true).recv.kid {
-        true
-    } else if Some(kid) == state.key_ref(false).recv.kid {
-        false
+    let specified_key = if Some(kid) == state.keys[0].recv.kid {
+        state.keys[0].nk.as_ref()
+    } else if Some(kid) == state.keys[1].recv.kid {
+        state.keys[1].nk.as_ref()
     } else {
         return Err(byzantine_fault!(OutOfSequence, true));
     };
 
-    let mut cipher = state
-        .key_ref(is_other)
-        .nk
-        .as_ref()
-        .ok_or(byzantine_fault!(OutOfSequence, true))?
-        .start_dec(n);
+    let mut cipher = specified_key.ok_or(byzantine_fault!(OutOfSequence, true))?.start_dec(n);
 
     // NOTE: This only works because we check the size of every received fragment in the receive
     // function, otherwise this could panic.
@@ -1794,6 +1784,7 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
     if cipher.finish((&fragment[tag_idx..]).try_into().unwrap()) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
+    drop(cipher);
 
     let (_, c) = from_nonce(n);
     if !session.window.update(c) {
@@ -1802,7 +1793,6 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
         return Err(byzantine_fault!(ExpiredCounter, true));
     }
 
-    drop(cipher);
     for fragment in fragments {
         let result = output_buffer.write(&fragment.as_ref()[HEADER_SIZE..]);
         if let Err(e) = result {
@@ -1859,46 +1849,14 @@ impl<App: ApplicationLayer> Session<App> {
     ///
     ///// The current ratchet state of this session.
     ///// The returned values are sensitive and should be securely erased before being dropped.
-    //pub fn ratchet_states(&self) -> [RatchetState; 2] {
-    //    let state = self.state.read().unwrap();
-    //    state.ratchet_states.clone()
-    //}
+    pub fn ratchet_states(&self) -> RatchetStates {
+        let state = self.state.read().unwrap();
+        RatchetStates::new(state.ratchet_state1.clone(), state.ratchet_state2.clone())
+    }
     /// The current ratchet count of this session.
-    //pub fn ratchet_count(&self) -> u64 {
-    //    self.state.read().unwrap().
-    //}
-    /// Mark a session as expired. This will make it impossible for this session to successfully
-    /// receive or send data or control packets. It is recommended to simply `drop` the session
-    /// instead, but this can provide some reassurance in complex shared ownership situations.
-    //pub fn expire(&self) {
-    //    if let Some(context) = self.context.upgrade() {
-    //        self.expire_inner(&context, &mut context.session_queue.lock().unwrap());
-    //    }
-    //}
-    //fn expire_inner(
-    //    &self,
-    //    context: &Arc<ContextInner<Application>>,
-    //    session_queue: &mut IndexedBinaryHeap<Weak<Session<Application>>, Reverse<i64>>,
-    //) {
-    //    // Prevent this session from being updated.
-    //    session_queue.remove(self.queue_idx);
-    //    self.session_has_expired.store(true, Ordering::Relaxed);
-    //    let _kex_lock = self.state_machine_lock.lock().unwrap();
-    //    let mut state = self.state.write().unwrap();
-    //    let mut session_map = context.session_map.write().unwrap();
-    //    for key in &state.cipher_states {
-    //        if let Some(pre_id) = key.as_ref().map(|k| k.local_key_id) {
-    //            session_map.remove(&pre_id);
-    //        }
-    //    }
-    //    use OfferStateMachine::*;
-    //    match &state.outgoing_offer {
-    //        NoiseXKPattern1or3(handshake_state) => session_map.remove(&handshake_state.local_key_id),
-    //        NoiseKKPattern1 { new_key_id, .. } => session_map.remove(new_key_id),
-    //        _ => None,
-    //    };
-    //    state.outgoing_offer = OfferStateMachine::Null;
-    //}
+    pub fn ratchet_count(&self) -> u64 {
+        self.state.read().unwrap().ratchet_state1.chain_len
+    }
     /// Check whether this session is established.
     pub fn established(&self) -> bool {
         let state = self.state.read().unwrap();
diff --git a/src/zssp.rs b/src/zssp.rs
index 78a7a30..29b90b3 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -98,13 +98,16 @@ fn send_with_fragmentation<PrpEnc: Aes256Enc>(
     let fragment_base_size = payload_len / fragment_count;
     let fragment_size_remainder = payload_len % fragment_count;
 
+    let mut header: [u8; HEADER_SIZE] = headered_packet[..HEADER_SIZE].try_into().unwrap();
+    header[FRAGMENT_COUNT_IDX] = fragment_count as u8;
+
     let mut i = HEADER_SIZE;
     for fragment_no in 0..fragment_count {
         let j = i + fragment_base_size + (fragment_no < fragment_size_remainder) as usize;
         let fragment = &mut headered_packet[i - HEADER_SIZE..j];
 
-        fragment[FRAGMENT_NO_IDX] = fragment_no as u8;
-        fragment[FRAGMENT_COUNT_IDX] = fragment_count as u8;
+        header[FRAGMENT_NO_IDX] = fragment_no as u8;
+        fragment[..HEADER_SIZE].copy_from_slice(&header);
 
         if let Some(hk_send) = hk_send {
             hk_send.encrypt_in_place((&mut fragment[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap());
@@ -482,7 +485,7 @@ impl<App: ApplicationLayer> Context<App> {
                     // This can occur naturally because either Bob's incoming_sessions cache got
                     // full so Alice's incoming session was dropped, or the session this packet
                     // was for was dropped by the application.
-                    return Err(byzantine_fault!(UnknownLocalKeyId, true));
+                    return Err(byzantine_fault!(UnknownLocalKeyId, false));
                 }
             }
         } else {
@@ -626,10 +629,10 @@ impl<App: ApplicationLayer> Context<App> {
         &self,
         app: App,
         mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
-        current_time: i64,
     ) -> i64 {
         let ctx = &self.0;
         let mut session_queue = ctx.session_queue.lock().unwrap();
+        let current_time = app.time();
         let mut next_service_time = current_time + App::SETTINGS.fragment_assembly_timeout as i64;
         // This update system takes heavy advantage of the fact that sessions only need to be updated
         // either roughly every second or roughly every hour. That big gap allows for minor optimizations.
@@ -668,6 +671,6 @@ impl<App: ApplicationLayer> Context<App> {
             .check_for_expiry(App::SETTINGS.fragment_assembly_timeout as i64, current_time);
         self.0.unassociated_handshake_states.service(current_time);
 
-        next_service_time
+        next_service_time - current_time
     }
 }

From 8e8aa4fa63695982ac1f3f44df9feb6cbcecf152 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 14:40:04 -0400
Subject: [PATCH 25/50] got it working

---
 examples/basic_test.rs     | 32 ++++++++++-----
 src/crypto/aes.rs          |  4 +-
 src/crypto_impl/openssl.rs | 26 +++++++------
 src/proto.rs               |  6 +--
 src/zeta.rs                | 80 +++++++++++++++++++++++++-------------
 src/zssp.rs                | 17 +++++---
 6 files changed, 108 insertions(+), 57 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 71fde87..e1d1a35 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -18,12 +18,13 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 
 use zssp::application::{
-    AcceptAction, ApplicationLayer, RatchetState, RatchetStates, RatchetUpdate, Settings, RATCHET_SIZE, IncomingSessionAction,
+    AcceptAction, ApplicationLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate, Settings,
+    RATCHET_SIZE,
 };
 use zssp::crypto::P384KeyPair;
 use zssp::crypto_impl::*;
-use zssp::Session;
 use zssp::result::ReceiveError;
+use zssp::Session;
 
 const TEST_MTU: usize = 1500;
 
@@ -71,7 +72,6 @@ impl ApplicationLayer for &TestApplication {
 
     type IncomingPacketBuffer = Vec<u8>;
 
-
     fn incoming_session(&self) -> IncomingSessionAction {
         IncomingSessionAction::Allow
     }
@@ -189,7 +189,7 @@ fn alice_main(
                         |_| Some((|b: &mut [u8]| alice_out.send(b.to_vec()).is_ok(), TEST_MTU)),
                         &0,
                         pkt,
-                        &mut output_data
+                        &mut output_data,
                     ) {
                         Ok(Unassociated) => {
                             //println!("[alice] ok");
@@ -234,13 +234,15 @@ fn alice_main(
             thread::sleep(Duration::from_millis(10));
         }
         // TODO: we need to more comprehensively test if re-opening the session works
-        if OsRng.next_u32() <= ((u32::MAX as f64) * 0.000005) as u32 {
+        if OsRng.next_u32() <= ((u32::MAX as f64) * 0.0000005) as u32 {
             alice_session = None;
         }
 
         if current_time >= next_service {
-            next_service =
-                current_time + context.service(alice_app, |_| Some((|b: &mut [u8]| alice_out.send(b.to_vec()).is_ok(), TEST_MTU)));
+            next_service = current_time
+                + context.service(alice_app, |_| {
+                    Some((|b: &mut [u8]| alice_out.send(b.to_vec()).is_ok(), TEST_MTU))
+                });
         }
     }
 }
@@ -278,7 +280,7 @@ fn bob_main(
                     |_| Some((|b: &mut [u8]| bob_out.send(b.to_vec()).is_ok(), TEST_MTU)),
                     &0,
                     pkt,
-                    &mut output_data
+                    &mut output_data,
                 ) {
                     Ok(Unassociated) => {}
                     Ok(Session(s, event)) => match event {
@@ -290,7 +292,14 @@ fn bob_main(
                             assert!(!output_data.is_empty());
                             //println!("[bob] received {}", output_data.len());
                             transferred += output_data.len() as u64 * 2; // *2 because we are also sending this many bytes back
-                            context.send(&s, |b| bob_out.send(b.to_vec()).is_ok(), &mut [0u8; TEST_MTU], &output_data).unwrap();
+                            context
+                                .send(
+                                    &s,
+                                    |b| bob_out.send(b.to_vec()).is_ok(),
+                                    &mut [0u8; TEST_MTU],
+                                    &output_data,
+                                )
+                                .unwrap();
                         }
                         Established => panic!(),
                         Rejected => panic!(),
@@ -319,7 +328,10 @@ fn bob_main(
         }
 
         if current_time >= next_service {
-            next_service = current_time + context.service(bob_app, |_| Some((|b: &mut [u8]| bob_out.send(b.to_vec()).is_ok(), TEST_MTU)));
+            next_service = current_time
+                + context.service(bob_app, |_| {
+                    Some((|b: &mut [u8]| bob_out.send(b.to_vec()).is_ok(), TEST_MTU))
+                });
         }
     }
 }
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index 9935564..e0e3752 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -42,14 +42,14 @@ pub trait Aes256Dec: Send + Sync {
 pub trait AesGcmEncContext {
     fn encrypt(&mut self, input: &[u8], output: &mut [u8]);
 
-    fn finish(&mut self) -> [u8; AES_GCM_TAG_SIZE];
+    fn finish(self) -> [u8; AES_GCM_TAG_SIZE];
 }
 
 pub trait AesGcmDecContext {
     fn decrypt_in_place(&mut self, data: &mut [u8]);
 
     #[must_use]
-    fn finish(&mut self, tag: &[u8; AES_GCM_TAG_SIZE]) -> bool;
+    fn finish(self, tag: &[u8; AES_GCM_TAG_SIZE]) -> bool;
 }
 
 pub trait HighThroughputAesGcmPool: Send + Sync {
diff --git a/src/crypto_impl/openssl.rs b/src/crypto_impl/openssl.rs
index fb17bf9..596352f 100644
--- a/src/crypto_impl/openssl.rs
+++ b/src/crypto_impl/openssl.rs
@@ -75,8 +75,6 @@ impl CipherCtx {
             tag.as_mut_ptr() as *mut _,
         ) > 0
     }
-
-    /// Sets the authentication tag for verification during decryption.
     #[allow(unused)]
     pub unsafe fn set_tag(&self, tag: &[u8]) -> bool {
         EVP_CIPHER_CTX_ctrl(
@@ -158,7 +156,7 @@ impl AesGcmEncContext for AesGcmOpenSSLEnc {
         unsafe { assert!(self.0.update::<true>(input, output.as_mut_ptr())) };
     }
 
-    fn finish(&mut self) -> [u8; AES_GCM_TAG_SIZE] {
+    fn finish(self) -> [u8; AES_GCM_TAG_SIZE] {
         let mut output = [0u8; AES_GCM_TAG_SIZE];
         unsafe {
             assert!(self.0.finalize::<true>());
@@ -175,26 +173,32 @@ impl AesGcmDecContext for AesGcmOpenSSLDec {
         unsafe { assert!(self.0.update::<false>(data, p)) };
     }
 
-    fn finish(&mut self, tag: &[u8; AES_GCM_TAG_SIZE]) -> bool {
+    fn finish(self, tag: &[u8; AES_GCM_TAG_SIZE]) -> bool {
         unsafe { self.0.set_tag(tag) && self.0.finalize::<false>() }
     }
 }
 
-pub struct AesGcmOpenSSLPool(Zeroizing<[u8; AES_256_KEY_SIZE]>, Zeroizing<[u8; AES_256_KEY_SIZE]>);
+pub struct AesGcmOpenSSLPool {
+    enc_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
+    dec_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
+}
 impl HighThroughputAesGcmPool for AesGcmOpenSSLPool {
     type EncContext<'a> = AesGcmOpenSSLEnc;
 
     type DecContext<'a> = AesGcmOpenSSLDec;
 
     fn new(encrypt_key: &[u8; AES_256_KEY_SIZE], decrypt_key: &[u8; AES_256_KEY_SIZE]) -> Self {
-        AesGcmOpenSSLPool(Zeroizing::new(*encrypt_key), Zeroizing::new(*decrypt_key))
+        AesGcmOpenSSLPool {
+            enc_key: Zeroizing::new(*encrypt_key),
+            dec_key: Zeroizing::new(*decrypt_key),
+        }
     }
 
     fn start_enc<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> AesGcmOpenSSLEnc {
         let ctx = CipherCtx::new().unwrap();
         unsafe {
             let t = openssl_sys::EVP_aes_256_gcm();
-            assert!(ctx.cipher_init::<true>(t, self.0.as_ptr(), nonce.as_ptr()));
+            assert!(ctx.cipher_init::<true>(t, self.enc_key.as_ptr(), nonce.as_ptr()));
             openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
         }
         AesGcmOpenSSLEnc(ctx)
@@ -204,7 +208,7 @@ impl HighThroughputAesGcmPool for AesGcmOpenSSLPool {
         let ctx = CipherCtx::new().unwrap();
         unsafe {
             let t = openssl_sys::EVP_aes_256_gcm();
-            assert!(ctx.cipher_init::<false>(t, self.0.as_ptr(), nonce.as_ptr()));
+            assert!(ctx.cipher_init::<false>(t, self.dec_key.as_ptr(), nonce.as_ptr()));
             openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
         }
         AesGcmOpenSSLDec(ctx)
@@ -246,12 +250,12 @@ impl LowThroughputAesGcm for AesGcmOpenSSL {
         let ctx = CipherCtx::new().unwrap();
         unsafe {
             let t = openssl_sys::EVP_aes_256_gcm();
-            assert!(ctx.cipher_init::<true>(t, key.as_ptr(), nonce.as_ptr()));
+            assert!(ctx.cipher_init::<false>(t, key.as_ptr(), nonce.as_ptr()));
             openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
 
-            assert!(ctx.update::<true>(aad, ptr::null_mut()));
+            assert!(ctx.update::<false>(aad, ptr::null_mut()));
             let p = data.as_mut_ptr();
-            assert!(ctx.update::<true>(data, p));
+            assert!(ctx.update::<false>(data, p));
 
             ctx.set_tag(tag) && ctx.finalize::<false>()
         }
diff --git a/src/proto.rs b/src/proto.rs
index 74ae800..8d20ca5 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -119,7 +119,7 @@ pub(crate) const PACKET_TYPE_USES_COUNTER_RANGE: std::ops::Range<u8> = 3..9;
 
 pub(crate) const HANDSHAKE_HELLO_MIN_SIZE: usize =
     KID_SIZE + P384_PUBLIC_KEY_SIZE + KYBER_PUBLIC_KEY_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
-pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RATCHET_SIZE;
+pub(crate) const HANDSHAKE_HELLO_MAX_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + RATCHET_SIZE + RATCHET_SIZE;
 
 pub(crate) const HANDSHAKE_HELLO_CHALLENGE_MIN_SIZE: usize = HANDSHAKE_HELLO_MIN_SIZE + CHALLENGE_SIZE;
 pub(crate) const HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE: usize = HANDSHAKE_HELLO_MAX_SIZE + CHALLENGE_SIZE;
@@ -145,7 +145,7 @@ pub(crate) const SESSION_REJECTED_SIZE: usize = AES_GCM_TAG_SIZE;
 pub(crate) const HEADERED_SESSION_REJECTED_SIZE: usize = SESSION_REJECTED_SIZE + HEADER_SIZE;
 
 pub(crate) const REKEY_SIZE: usize = P384_PUBLIC_KEY_SIZE + KID_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
-pub(crate) const HEADERED_REKEY_SIZE: usize = P384_PUBLIC_KEY_SIZE + KID_SIZE + AES_GCM_TAG_SIZE + AES_GCM_TAG_SIZE;
+pub(crate) const HEADERED_REKEY_SIZE: usize = REKEY_SIZE + HEADER_SIZE;
 
 /// The application has the ability to attach a data payload to Alice's handshake.
 /// It will be the first payload Bob receives from Alice.
@@ -177,6 +177,6 @@ pub(crate) const MAX_UNASSOCIATED_FRAGMENTS: usize = 32 * 32;
 
 /// The maximum size a packet that is not associated to a session may be.
 /// Excludes the size of headers for fragmentation.
-pub(crate) const MAX_UNASSOCIATED_PACKET_SIZE: usize = HANDSHAKE_HELLO_MAX_SIZE;
+pub(crate) const MAX_UNASSOCIATED_PACKET_SIZE: usize = HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE;
 
 pub(crate) const SESSION_MAX_FRAGMENTS_OOO: usize = 64;
diff --git a/src/zeta.rs b/src/zeta.rs
index 07f7c74..8bba2b6 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -185,10 +185,10 @@ pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
     R1 {
         noise: SymmetricState<App>,
         e_secret: App::KeyPair,
-        k1: ArrayVec<u8, REKEY_SIZE>,
+        k1: ArrayVec<u8, HEADERED_REKEY_SIZE>,
     },
     R2 {
-        k2: ArrayVec<u8, REKEY_SIZE>,
+        k2: ArrayVec<u8, HEADERED_REKEY_SIZE>,
     },
 }
 
@@ -323,7 +323,6 @@ fn create_a1_state<App: ApplicationLayer>(
     let i = x1.len();
     let (e1_secret, e1_public) = App::Kem::generate(rng.lock().unwrap().deref_mut());
     x1.extend(e1_public);
-    x1.extend([0u8; AES_GCM_NONCE_SIZE]);
     let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), &mut x1[i..]);
     x1.extend(tag);
     // Process message pattern 1 payload.
@@ -466,7 +465,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     //    ...
     //    -> e, es, e1
     //    <- e, ee, ekem1, psk
-    if !(HANDSHAKE_HELLO_CHALLENGE_MIN_SIZE..=HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE).contains(&x1.len()) {
+    if !(HANDSHAKE_HELLO_MIN_SIZE..=HANDSHAKE_HELLO_MAX_SIZE).contains(&x1.len()) {
         return Err(byzantine_fault!(InvalidPacket, true));
     }
 
@@ -493,14 +492,14 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
         .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 1 e1 token.
     let j = i + KYBER_PUBLIC_KEY_SIZE;
-    let k = i + AES_GCM_TAG_SIZE;
+    let k = j + AES_GCM_TAG_SIZE;
     let tag = x1[j..k].try_into().unwrap();
     if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), &mut x1[i..j], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let e1_start = i;
     let e1_end = j;
-    i = j;
+    i = k;
     // Process message pattern 1 payload.
     let k = x1.len();
     let j = k - AES_GCM_TAG_SIZE;
@@ -529,9 +528,10 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
         }
         RatchetState::empty()
     };
+
     let mut hk_recv = Zeroizing::new([0u8; HASHLEN]);
     let mut hk_send = Zeroizing::new([0u8; HASHLEN]);
-    noise.get_ask(hmac, LABEL_HEADER_KEY, &mut hk_recv, &mut hk_send);
+    noise.get_ask(hmac, LABEL_HEADER_KEY, &mut hk_send, &mut hk_recv);
 
     let mut x2 = ArrayVec::<u8, HEADERED_HANDSHAKE_RESPONSE_SIZE>::new();
     x2.extend([0u8; HEADER_SIZE]);
@@ -660,7 +660,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         }
         noise.mix_key(hmac, ekem1_secret.as_ref());
         drop(ekem1_secret);
-        i = j;
+        i = k;
         // We attempt to decrypt the payload at most three times. First two times with
         // the ratchet key Alice remembers, and final time with a ratchet
         // key of zero if Alice allows ratchet downgrades.
@@ -1705,19 +1705,22 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
 
     let payload_mtu = mtu - HEADER_SIZE;
     debug_assert!(payload_mtu >= 4);
-    let fragment_count = payload.len().saturating_add(payload_mtu - 1) / payload_mtu; // Ceiling div.
-    let fragment_base_size = payload.len() / fragment_count;
-    let fragment_size_remainder = payload.len() % fragment_count;
+    let tagged_payload_len = payload.len() + AES_GCM_TAG_SIZE;
+    let fragment_count = tagged_payload_len.saturating_add(payload_mtu - 1) / payload_mtu; // Ceiling div.
+    let fragment_base_size = tagged_payload_len / fragment_count;
+    let fragment_size_remainder = tagged_payload_len % fragment_count;
 
-    mtu_sized_buffer[..KID_SIZE].copy_from_slice(&key.send.kid.unwrap().get().to_be_bytes());
-    mtu_sized_buffer[FRAGMENT_COUNT_IDX] = fragment_count as u8;
-    mtu_sized_buffer[PACKET_NONCE_START..].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
+    let mut header = [0u8; HEADER_SIZE];
+    header[..KID_SIZE].copy_from_slice(&key.send.kid.unwrap().get().to_be_bytes());
+    header[FRAGMENT_COUNT_IDX] = fragment_count as u8;
+    header[PACKET_NONCE_START..].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
 
     let mut i = 0;
-    for fragment_no in 0..fragment_count {
+    for fragment_no in 0..fragment_count - 1 {
         let fragment_len = fragment_base_size + (fragment_no < fragment_size_remainder) as usize;
         let j = i + fragment_len;
 
+        mtu_sized_buffer[..HEADER_SIZE].copy_from_slice(&header);
         mtu_sized_buffer[FRAGMENT_NO_IDX] = fragment_no as u8;
         cipher.encrypt(
             &payload[i..j],
@@ -1735,7 +1738,29 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
         }
         i = j;
     }
-    drop(cipher);
+    let fragment_no = fragment_count - 1;
+    let payload_rem = payload.len() - i;
+    let fragment_len = payload_rem + AES_GCM_TAG_SIZE;
+    debug_assert_eq!(fragment_len, fragment_base_size);
+
+    mtu_sized_buffer[..HEADER_SIZE].copy_from_slice(&header);
+    mtu_sized_buffer[FRAGMENT_NO_IDX] = fragment_no as u8;
+    cipher.encrypt(
+        &payload[i..],
+        &mut mtu_sized_buffer[HEADER_SIZE..HEADER_SIZE + payload_rem],
+    );
+    mtu_sized_buffer[HEADER_SIZE + payload_rem..HEADER_SIZE + fragment_len].copy_from_slice(&cipher.finish());
+
+    state.hk_send.encrypt_in_place(
+        (&mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END])
+            .try_into()
+            .unwrap(),
+    );
+
+    if !send(&mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
+        return Ok(());
+    }
+
     drop(state);
 
     if should_rekey {
@@ -1754,11 +1779,12 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
     session: &Arc<Session<App>>,
     state: RwLockReadGuard<'_, MutableState<App>>,
     kid: NonZeroU32,
-    n: &[u8; AES_GCM_NONCE_SIZE],
+    nonce: &[u8; AES_GCM_NONCE_SIZE],
     fragments: &mut [App::IncomingPacketBuffer],
     mut output_buffer: impl Write,
 ) -> Result<(), ReceiveError<App::StorageError>> {
     use FaultType::*;
+    debug_assert!(!fragments.is_empty());
 
     let specified_key = if Some(kid) == state.keys[0].recv.kid {
         state.keys[0].nk.as_ref()
@@ -1768,25 +1794,27 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
         return Err(byzantine_fault!(OutOfSequence, true));
     };
 
-    let mut cipher = specified_key.ok_or(byzantine_fault!(OutOfSequence, true))?.start_dec(n);
+    let mut cipher = specified_key
+        .ok_or(byzantine_fault!(OutOfSequence, true))?
+        .start_dec(nonce);
+    let (_, c) = from_nonce(nonce);
 
     // NOTE: This only works because we check the size of every received fragment in the receive
     // function, otherwise this could panic.
-    let mut i = 0;
-    while i + 1 < fragments.len() {
+    for i in 0..fragments.len() - 1 {
         let fragment = &mut fragments[i].as_mut()[HEADER_SIZE..];
+        debug_assert!(fragment.len() >= AES_GCM_TAG_SIZE);
         cipher.decrypt_in_place(fragment);
-        i += 1;
     }
-    let fragment = &mut fragments[i].as_mut()[HEADER_SIZE..];
-    let tag_idx = fragment.len() - AES_GCM_NONCE_SIZE;
+    let fragment = &mut fragments[fragments.len() - 1].as_mut()[HEADER_SIZE..];
+    debug_assert!(fragment.len() >= AES_GCM_TAG_SIZE);
+    let tag_idx = fragment.len() - AES_GCM_TAG_SIZE;
     cipher.decrypt_in_place(&mut fragment[..tag_idx]);
-    if cipher.finish((&fragment[tag_idx..]).try_into().unwrap()) {
+
+    if !cipher.finish((&fragment[tag_idx..]).try_into().unwrap()) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    drop(cipher);
 
-    let (_, c) = from_nonce(n);
     if !session.window.update(c) {
         // This error is marked as not happening naturally, but it could occur if something about
         // the transport protocol is duplicating packets.
diff --git a/src/zssp.rs b/src/zssp.rs
index 29b90b3..17c24fe 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -106,8 +106,8 @@ fn send_with_fragmentation<PrpEnc: Aes256Enc>(
         let j = i + fragment_base_size + (fragment_no < fragment_size_remainder) as usize;
         let fragment = &mut headered_packet[i - HEADER_SIZE..j];
 
-        header[FRAGMENT_NO_IDX] = fragment_no as u8;
         fragment[..HEADER_SIZE].copy_from_slice(&header);
+        fragment[FRAGMENT_NO_IDX] = fragment_no as u8;
 
         if let Some(hk_send) = hk_send {
             hk_send.encrypt_in_place((&mut fragment[HEADER_AUTH_START..HEADER_AUTH_END]).try_into().unwrap());
@@ -536,11 +536,11 @@ impl<App: ApplicationLayer> Context<App> {
                     return Err(byzantine_fault!(InvalidPacket, true));
                 }
                 // Process recv challenge layer.
+                let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
                 let hash = &mut App::Hash::new();
                 match app.incoming_session() {
                     IncomingSessionAction::Allow => {}
                     IncomingSessionAction::Challenge => {
-                        let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
                         let result = ctx.challenge.process_hello(
                             hash,
                             remote_address,
@@ -569,9 +569,16 @@ impl<App: ApplicationLayer> Context<App> {
                 }
 
                 // Process recv zeta layer.
-                received_x1_trans(&app, ctx, hash, &nonce, assembled_packet, |packet, hk_send| {
-                    send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
-                })?;
+                received_x1_trans(
+                    &app,
+                    ctx,
+                    hash,
+                    &nonce,
+                    &mut assembled_packet[..challenge_start],
+                    |packet, hk_send| {
+                        send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
+                    },
+                )?;
                 log!(app, X1IsAuthSentX2);
 
                 Ok(ReceiveOk::Unassociated)

From de04653f606ead4947fe11b5fbdd2b6fb7efef0d Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 14:52:47 -0400
Subject: [PATCH 26/50] refactored dependencies

---
 Cargo.toml             |  7 +++----
 examples/basic_test.rs |  8 --------
 src/crypto/mod.rs      |  1 +
 src/crypto_impl/mod.rs | 23 ++++++++++++++---------
 src/frag_cache.rs      |  8 --------
 src/fragged.rs         |  8 --------
 src/handshake_cache.rs |  8 --------
 src/lib.rs             | 17 +++++------------
 src/zssp.rs            | 10 ----------
 9 files changed, 23 insertions(+), 67 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index e291b16..48a75dc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,12 +19,11 @@ pqc_kyber = { version = "0.6.0", default-features = false, features = ["kyber102
 p384 = { version = "0.13.0", default-features = false, features = ["ecdh"], optional = true }
 sha2 = { version = "0.10.7", default-features = false, optional = true }
 hmac = { version = "0.12.1", default-features = false, optional = true }
-openssl-sys = { version = "0.9.91", default-features = false }
+openssl-sys = { version = "0.9.91", default-features = false, optional = true }
 
 [features]
-default = ["debug", "p384", "hmac", "pqc_kyber"]
-sha2 = ["dep:sha2"]
-hmac = ["dep:hmac", "sha2"]
+default = ["debug", "p384", "sha2", "pqc_kyber", "openssl-sys"]
+sha2 = ["dep:sha2", "dep:hmac"]
 logging = []
 debug = ["logging"]
 
diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index e1d1a35..8e45b0e 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -1,11 +1,3 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-
 use std::collections::HashMap;
 use std::iter::ExactSizeIterator;
 use std::str::FromStr;
diff --git a/src/crypto/mod.rs b/src/crypto/mod.rs
index 16279f0..0bd3beb 100644
--- a/src/crypto/mod.rs
+++ b/src/crypto/mod.rs
@@ -14,6 +14,7 @@ pub use kyber1024::*;
 // exact version of them.
 pub use rand_core;
 pub use zeroize;
+pub use arrayvec;
 
 /// Constant time byte slice equality.
 pub fn secure_eq<A: AsRef<[u8]> + ?Sized, B: AsRef<[u8]> + ?Sized>(a: &A, b: &B) -> bool {
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
index d414a06..cdd11cd 100644
--- a/src/crypto_impl/mod.rs
+++ b/src/crypto_impl/mod.rs
@@ -2,23 +2,28 @@
 mod kyber1024;
 #[cfg(feature = "pqc_kyber")]
 pub use kyber1024::*;
+#[cfg(feature = "pqc_kyber")]
+pub use pqc_kyber;
+
 #[cfg(feature = "p384")]
 mod p384_impl;
 #[cfg(feature = "p384")]
 pub use p384_impl::*;
+#[cfg(feature = "p384")]
+pub use p384;
+
 #[cfg(feature = "sha2")]
 mod sha512;
 #[cfg(feature = "sha2")]
 pub use sha512::*;
-
-mod openssl;
-pub use openssl::*;
-
-#[cfg(feature = "hmac")]
+#[cfg(feature = "sha2")]
 pub use hmac;
-#[cfg(feature = "p384")]
-pub use p384;
-#[cfg(feature = "pqc_kyber")]
-pub use pqc_kyber;
 #[cfg(feature = "sha2")]
 pub use sha2;
+
+#[cfg(feature = "openssl-sys")]
+mod openssl;
+#[cfg(feature = "openssl-sys")]
+pub use openssl::*;
+#[cfg(feature = "openssl-sys")]
+pub use openssl_sys;
diff --git a/src/frag_cache.rs b/src/frag_cache.rs
index 2423cda..e9f15b9 100644
--- a/src/frag_cache.rs
+++ b/src/frag_cache.rs
@@ -1,11 +1,3 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-
 use std::collections::hash_map::RandomState;
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::mem::MaybeUninit;
diff --git a/src/fragged.rs b/src/fragged.rs
index 54b90d9..b3c293a 100644
--- a/src/fragged.rs
+++ b/src/fragged.rs
@@ -1,11 +1,3 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-
 use arrayvec::ArrayVec;
 use std::mem::{needs_drop, zeroed, MaybeUninit};
 
diff --git a/src/handshake_cache.rs b/src/handshake_cache.rs
index 75b4aa4..3939cc7 100644
--- a/src/handshake_cache.rs
+++ b/src/handshake_cache.rs
@@ -1,11 +1,3 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- * (c) ZeroTier, Inc.
- * https://www.zerotier.com/
- */
-
 use std::num::NonZeroU32;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock};
diff --git a/src/lib.rs b/src/lib.rs
index 626e58c..cb8e8c0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,28 +9,21 @@ pub mod crypto;
 pub mod crypto_impl;
 
 mod antireplay;
-pub mod application;
 mod challenge;
 mod frag_cache;
 mod fragged;
 mod handshake_cache;
 mod indexed_heap;
-
 mod log_event;
-pub use log_event::*;
-
-pub mod proto;
 mod ratchet_state;
-pub mod result;
 mod symmetric_state;
 mod zeta;
 mod zssp;
 
+pub mod proto;
+pub mod result;
+pub mod application;
+
+pub use log_event::*;
 pub use zeta::*;
 pub use zssp::*;
-//pub mod error;
-//pub use crate::applicationlayer::ApplicationLayer;
-//pub use crate::log_event::LogEvent;
-//pub use crate::proto::{IDENTITY_MAX_SIZE, MIN_PACKET_SIZE, MIN_TRANSPORT_MTU};
-//pub use crate::ratchet_state::RatchetState;
-//pub use crate::zssp::{Context, ContextInner, IncomingSessionAction, ReceiveResult, Session, SessionEvent};
diff --git a/src/zssp.rs b/src/zssp.rs
index 17c24fe..dd0961c 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -1,13 +1,3 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
-* License, v. 2.0. If a copy of the MPL was not distributed with this
-* file, You can obtain one at https://mozilla.org/MPL/2.0/.
-*
-* (c) ZeroTier, Inc.
-* https://www.zerotier.com/
-*/
-// ZSSP: ZeroTier Secure Session Protocol
-// FIPS compliant Noise_XK with Jedi powers (Kyber1024) and built-in attack-resistant large payload (fragmentation) support.
-
 use std::cmp::Reverse;
 use std::collections::HashMap;
 use std::hash::Hash;

From 597e5b29b43499d315fba949b3ddf2ce0ebc3a59 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 15:48:59 -0400
Subject: [PATCH 27/50] fixed wrong constant bug

---
 examples/basic_test.rs | 12 +++++++-----
 src/proto.rs           |  2 +-
 src/zssp.rs            |  2 +-
 3 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 8e45b0e..537cc02 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -132,6 +132,7 @@ impl ApplicationLayer for &TestApplication {
     }
 }
 
+#[allow(unused)]
 fn alice_main(
     run: &AtomicBool,
     packet_success_rate: u32,
@@ -205,8 +206,8 @@ fn alice_main(
                             }
                         }
                     }
-                } else if OsRng.next_u32() | 1 > 0 {
-                    let _ = recursive_out.send(pkt);
+                //} else if OsRng.next_u32() | 1 > 0 {
+                //    let _ = recursive_out.send(pkt);
                 }
             } else {
                 break;
@@ -239,6 +240,7 @@ fn alice_main(
     }
 }
 
+#[allow(unused)]
 fn bob_main(
     run: &AtomicBool,
     packet_success_rate: u32,
@@ -304,8 +306,8 @@ fn bob_main(
                         }
                     }
                 }
-            } else if OsRng.next_u32() | 1 > 0 {
-                let _ = recursive_out.try_send(pkt);
+            //} else if OsRng.next_u32() | 1 > 0 {
+            //    let _ = recursive_out.try_send(pkt);
             }
         }
 
@@ -387,7 +389,7 @@ fn core(time: u64, packet_success_rate: u32) {
 fn main() {
     let args = std::env::args();
     let packet_success_rate = if args.len() <= 1 {
-        let default_success_rate = 1.0;
+        let default_success_rate = 0.5;
         ((u32::MAX as f64) * default_success_rate) as u32
     } else {
         ((u32::MAX as f64) * f64::from_str(args.last().unwrap().as_str()).unwrap()) as u32
diff --git a/src/proto.rs b/src/proto.rs
index 8d20ca5..e5a9249 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -92,7 +92,7 @@ pub(crate) const EXPIRE_AFTER_USES: u64 = 1 << 32 - 1;
 /// this amount out of order relative to other received counters, it is likely to be
 /// rejected on the basis that the session can't remember if this counter was replayed.
 /// Increasing this value makes a session consume more memory.
-pub(crate) const COUNTER_WINDOW_MAX_OOO: usize = 64;
+pub(crate) const COUNTER_WINDOW_MAX_OOO: usize = 128;
 /// Maximum number of counter steps that the counter is allowed to skip ahead.
 /// This cannot be changed away from 2^24 without changing the header nonce handling code.
 pub(crate) const COUNTER_WINDOW_MAX_SKIP_AHEAD: u64 = 1 << 24;
diff --git a/src/zssp.rs b/src/zssp.rs
index dd0961c..95a2398 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -490,7 +490,7 @@ impl<App: ApplicationLayer> Context<App> {
                 }
             }
 
-            let mut buffer = ArrayVec::<u8, HANDSHAKE_HELLO_MAX_SIZE>::new();
+            let mut buffer = ArrayVec::<u8, HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE>::new();
             let assembled_packet = if fragment_count > 1 {
                 self.0.unassociated_defrag_cache.lock().unwrap().assemble(
                     &nonce,

From 23941c979765311e5831d9613987bdc6cf3a7381 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 8 Aug 2023 16:03:46 -0400
Subject: [PATCH 28/50] removed some key inits

---
 examples/basic_test.rs |  2 +-
 src/zeta.rs            | 60 +++++++++++-------------------------------
 2 files changed, 17 insertions(+), 45 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 537cc02..7befb32 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -389,7 +389,7 @@ fn core(time: u64, packet_success_rate: u32) {
 fn main() {
     let args = std::env::args();
     let packet_success_rate = if args.len() <= 1 {
-        let default_success_rate = 0.5;
+        let default_success_rate = 1.0;
         ((u32::MAX as f64) * default_success_rate) as u32
     } else {
         ((u32::MAX as f64) * f64::from_str(args.last().unwrap().as_str()).unwrap()) as u32
diff --git a/src/zeta.rs b/src/zeta.rs
index 8bba2b6..5649a59 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -193,34 +193,6 @@ pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
 }
 
 impl<App: ApplicationLayer> SymmetricState<App> {
-    fn write_e<const CAP: usize>(
-        &mut self,
-        hash: &mut App::Hash,
-        hmac: &mut App::Hmac,
-        rng: &Mutex<App::Rng>,
-        packet: &mut ArrayVec<u8, CAP>,
-    ) -> App::KeyPair {
-        let e_secret = App::KeyPair::generate(rng.lock().unwrap().deref_mut());
-        let pub_key = e_secret.public_key_bytes();
-        packet.extend(pub_key);
-        self.mix_hash(hash, &pub_key);
-        self.mix_key(hmac, &pub_key);
-        e_secret
-    }
-    fn read_e(
-        &mut self,
-        hash: &mut App::Hash,
-        hmac: &mut App::Hmac,
-        i: &mut usize,
-        packet: &[u8],
-    ) -> Option<App::PublicKey> {
-        let j = *i + P384_PUBLIC_KEY_SIZE;
-        let pub_key = &packet[*i..j];
-        self.mix_hash(hash, pub_key);
-        self.mix_key(hmac, pub_key);
-        *i = j;
-        App::PublicKey::from_bytes((pub_key).try_into().unwrap())
-    }
     fn write_e_no_init<const CAP: usize>(
         &mut self,
         hash: &mut App::Hash,
@@ -316,7 +288,7 @@ fn create_a1_state<App: ApplicationLayer>(
     noise.mix_hash(hash, &kid);
     noise.mix_hash(hash, &s_remote.to_bytes());
     // Process message pattern 1 e token.
-    let e_secret = noise.write_e(hash, hmac, rng, &mut x1);
+    let e_secret = noise.write_e_no_init(hash, hmac, rng, &mut x1);
     // Process message pattern 1 es token.
     noise.mix_dh(hmac, &e_secret, s_remote)?;
     // Process message pattern 1 e1 token.
@@ -484,7 +456,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     i = j;
     // Process message pattern 1 e token.
     let e_remote = noise
-        .read_e(hash, hmac, &mut i, &x1)
+        .read_e_no_init(hash, hmac, &mut i, &x1)
         .ok_or(byzantine_fault!(FailedAuth, true))?;
     // Process message pattern 1 es token.
     noise
@@ -536,7 +508,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     let mut x2 = ArrayVec::<u8, HEADERED_HANDSHAKE_RESPONSE_SIZE>::new();
     x2.extend([0u8; HEADER_SIZE]);
     // Process message pattern 2 e token.
-    let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut x2);
+    let e_secret = noise.write_e_no_init(hash, hmac, &ctx.rng, &mut x2);
     // Process message pattern 2 ee token.
     noise
         .mix_dh(hmac, &e_secret, &e_remote)
@@ -554,7 +526,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
         x2.extend(ekem1);
         let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]);
         x2.extend(tag);
-        noise.mix_key(hmac, ekem1_secret.as_ref());
+        noise.mix_key_no_init(hmac, ekem1_secret.as_ref());
     }
     // Process message pattern 2 psk2 token.
     noise.mix_key_and_hash(hash, hmac, ratchet_state.key.as_ref());
@@ -638,7 +610,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         let mut i = 0;
         // Process message pattern 2 e token.
         let e_remote = noise
-            .read_e(hash, hmac, &mut i, &x2)
+            .read_e_no_init(hash, hmac, &mut i, &x2)
             .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 ee token.
         noise
@@ -658,7 +630,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         {
             return Err(byzantine_fault!(FailedAuth, true));
         }
-        noise.mix_key(hmac, ekem1_secret.as_ref());
+        noise.mix_key_no_init(hmac, ekem1_secret.as_ref());
         drop(ekem1_secret);
         i = k;
         // We attempt to decrypt the payload at most three times. First two times with
@@ -1262,11 +1234,11 @@ fn timeout_trans<App: ApplicationLayer>(
             noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
             noise.mix_hash(hash, &session.s_remote.to_bytes());
             // Process message pattern 1 psk0 token.
-            noise.mix_key_and_hash(hash, hmac, state.ratchet_state1.key.as_ref());
+            noise.mix_key_and_hash_no_init(hash, hmac, state.ratchet_state1.key.as_ref());
             // Process message pattern 1 e token.
-            let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut k1);
+            let e_secret = noise.write_e_no_init(hash, hmac, &ctx.rng, &mut k1);
             // Process message pattern 1 es token.
-            if noise.mix_dh(hmac, &e_secret, &session.s_remote).is_none() {
+            if noise.mix_dh_no_init(hmac, &e_secret, &session.s_remote).is_none() {
                 return None;
             }
             // Process message pattern 1 ss token.
@@ -1439,14 +1411,14 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         noise.mix_hash(hash, &session.s_remote.to_bytes());
         noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
         // Process message pattern 1 psk0 token.
-        noise.mix_key_and_hash(hash, hmac, state.ratchet_state1.key.as_ref());
+        noise.mix_key_and_hash_no_init(hash, hmac, state.ratchet_state1.key.as_ref());
         // Process message pattern 1 e token.
         let e_remote = noise
-            .read_e(hash, hmac, &mut i, &k1)
+            .read_e_no_init(hash, hmac, &mut i, &k1)
             .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 es token.
         noise
-            .mix_dh(hmac, &ctx.s_secret, &e_remote)
+            .mix_dh_no_init(hmac, &ctx.s_secret, &e_remote)
             .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 1 ss token.
         noise.mix_key(hmac, session.noise_kk_ss.as_ref());
@@ -1463,10 +1435,10 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         let mut k2 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
         k2.extend([0u8; HEADER_SIZE]);
         // Process message pattern 2 e token.
-        let e_secret = noise.write_e(hash, hmac, &ctx.rng, &mut k2);
+        let e_secret = noise.write_e_no_init(hash, hmac, &ctx.rng, &mut k2);
         // Process message pattern 2 ee token.
         noise
-            .mix_dh(hmac, &e_secret, &e_remote)
+            .mix_dh_no_init(hmac, &e_secret, &e_remote)
             .ok_or(byzantine_fault!(FailedAuth, true))?;
         // Process message pattern 2 se token.
         noise
@@ -1590,11 +1562,11 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             let hmac = &mut App::Hmac::new();
             // Process message pattern 2 e token.
             let e_remote = noise
-                .read_e(hash, hmac, &mut i, &k2)
+                .read_e_no_init(hash, hmac, &mut i, &k2)
                 .ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 ee token.
             noise
-                .mix_dh(hmac, e_secret, &e_remote)
+                .mix_dh_no_init(hmac, e_secret, &e_remote)
                 .ok_or(byzantine_fault!(FailedAuth, true))?;
             // Process message pattern 2 se token.
             noise

From 5cd2d8f45f8705646bd529915ef50f5a3cf0386f Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 9 Aug 2023 12:07:59 -0400
Subject: [PATCH 29/50] added downgrade warning

---
 examples/basic_test.rs | 16 +++++++---------
 src/crypto/aes.rs      | 12 ++++++++----
 src/crypto/mod.rs      |  2 +-
 src/crypto_impl/mod.rs |  8 ++++----
 src/lib.rs             |  8 ++++----
 src/result.rs          |  8 ++++++--
 src/zeta.rs            | 42 +++++++++++++++++++++---------------------
 src/zssp.rs            | 30 +++++++++++++++++++++---------
 8 files changed, 72 insertions(+), 54 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 7befb32..3bbf1f0 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -195,9 +195,8 @@ fn alice_main(
                                 assert!(!output_data.is_empty());
                                 //println!("[alice] received {}", data.len());
                             }
-                            NewSession => panic!(),
-                            Rejected => panic!(),
                             Control => (),
+                            _ => panic!(),
                         },
                         Err(e) => {
                             println!("[alice] ERROR {:?}", e);
@@ -206,8 +205,8 @@ fn alice_main(
                             }
                         }
                     }
-                //} else if OsRng.next_u32() | 1 > 0 {
-                //    let _ = recursive_out.send(pkt);
+                    //} else if OsRng.next_u32() | 1 > 0 {
+                    //    let _ = recursive_out.send(pkt);
                 }
             } else {
                 break;
@@ -278,7 +277,7 @@ fn bob_main(
                 ) {
                     Ok(Unassociated) => {}
                     Ok(Session(s, event)) => match event {
-                        NewSession => {
+                        NewSession | NewDowngradedSession => {
                             println!("[bob] new session, took {}s", current_time as f32 / 1000.0);
                             let _ = bob_session.replace(s);
                         }
@@ -295,9 +294,8 @@ fn bob_main(
                                 )
                                 .unwrap();
                         }
-                        Established => panic!(),
-                        Rejected => panic!(),
                         Control => (),
+                        _ => panic!(),
                     },
                     Err(e) => {
                         println!("[bob] ERROR {:?}", e);
@@ -306,8 +304,8 @@ fn bob_main(
                         }
                     }
                 }
-            //} else if OsRng.next_u32() | 1 > 0 {
-            //    let _ = recursive_out.try_send(pkt);
+                //} else if OsRng.next_u32() | 1 > 0 {
+                //    let _ = recursive_out.try_send(pkt);
             }
         }
 
diff --git a/src/crypto/aes.rs b/src/crypto/aes.rs
index e0e3752..7921c30 100644
--- a/src/crypto/aes.rs
+++ b/src/crypto/aes.rs
@@ -10,12 +10,14 @@ pub const AES_GCM_NONCE_SIZE: usize = 12;
 /// algorithm is secure.
 ///
 /// Instances must securely delete their keys when dropped or reset.
-pub trait Aes256Enc: Send + Sync {
+pub trait Aes256Enc: Sized + Send + Sync {
     fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self;
 
     /// Change the encryption key to `key` so that all future encryption is performed with it.
     /// This function is very rarely called so it does not have to be particularly efficient.
-    fn reset(&mut self, key: &[u8; AES_256_KEY_SIZE]);
+    fn reset(&mut self, key: &[u8; AES_256_KEY_SIZE]) {
+        *self = Self::new(key);
+    }
 
     /// Decrypt the given `block` of plaintext directly using the AES block cipher
     /// (i.e. AES-256 in zero-padding ECB mode).
@@ -26,12 +28,14 @@ pub trait Aes256Enc: Send + Sync {
 /// A trait for decrypting individual blocks of plaintext using AES-256.
 ///
 /// Instances must securely delete their keys when dropped or reset.
-pub trait Aes256Dec: Send + Sync {
+pub trait Aes256Dec: Sized + Send + Sync {
     fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self;
 
     /// Change the decryption key to `key` so that all future decryption is performed with it.
     /// This function is very rarely called so it does not have to be particularly efficient.
-    fn reset(&mut self, key: &[u8; AES_256_KEY_SIZE]);
+    fn reset(&mut self, key: &[u8; AES_256_KEY_SIZE]) {
+        *self = Self::new(key);
+    }
 
     /// Decrypt the given `block` of ciphertext directly using the AES 256 block cipher
     /// (i.e. AES-256 in zero-padding ECB mode).
diff --git a/src/crypto/mod.rs b/src/crypto/mod.rs
index 0bd3beb..2b6ea78 100644
--- a/src/crypto/mod.rs
+++ b/src/crypto/mod.rs
@@ -12,9 +12,9 @@ pub use kyber1024::*;
 
 // We re-export our dependencies so it is less of a headache for the implementor to use the same
 // exact version of them.
+pub use arrayvec;
 pub use rand_core;
 pub use zeroize;
-pub use arrayvec;
 
 /// Constant time byte slice equality.
 pub fn secure_eq<A: AsRef<[u8]> + ?Sized, B: AsRef<[u8]> + ?Sized>(a: &A, b: &B) -> bool {
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
index cdd11cd..d481ff4 100644
--- a/src/crypto_impl/mod.rs
+++ b/src/crypto_impl/mod.rs
@@ -8,18 +8,18 @@ pub use pqc_kyber;
 #[cfg(feature = "p384")]
 mod p384_impl;
 #[cfg(feature = "p384")]
-pub use p384_impl::*;
-#[cfg(feature = "p384")]
 pub use p384;
+#[cfg(feature = "p384")]
+pub use p384_impl::*;
 
 #[cfg(feature = "sha2")]
 mod sha512;
 #[cfg(feature = "sha2")]
-pub use sha512::*;
-#[cfg(feature = "sha2")]
 pub use hmac;
 #[cfg(feature = "sha2")]
 pub use sha2;
+#[cfg(feature = "sha2")]
+pub use sha512::*;
 
 #[cfg(feature = "openssl-sys")]
 mod openssl;
diff --git a/src/lib.rs b/src/lib.rs
index cb8e8c0..caf7a4d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -20,10 +20,10 @@ mod symmetric_state;
 mod zeta;
 mod zssp;
 
+pub mod application;
 pub mod proto;
 pub mod result;
-pub mod application;
 
-pub use log_event::*;
-pub use zeta::*;
-pub use zssp::*;
+pub use crate::log_event::*;
+pub use crate::zeta::*;
+pub use crate::zssp::*;
diff --git a/src/result.rs b/src/result.rs
index f78e035..8c19d85 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -19,13 +19,15 @@ pub enum OpenError<IoError> {
 /// Depending on the error type trying again may not work.
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum SendError {
-    /// An invalid parameter was supplied to the function.
-    InvalidParameter,
+    /// An invalid mtu was supplied to the function. The MTU can be no smaller than 128 bytes.
+    MtuTooSmall,
 
     /// The session has been marked as expired and refuses to send data.
     /// Several components of ZSSP can cause this to occur, but the most likely situation to be seen
     /// in practice is where rekeying repeatedly fails due to exceedingly bad network conditions.
     ///
+    /// The user can also explicitly cause this to occur by manually calling `expire` on a session.
+    ///
     /// The associated session will no longer send or receive data and must be immediately dropped.
     SessionExpired,
 
@@ -144,6 +146,7 @@ pub enum SessionEvent {
     /// If the session Arc returned is dropped, the session with this peer will be immediately
     /// terminated. Save the session Arc to some long lived datastructure to keep it alive.
     NewSession,
+    NewDowngradedSession,
     /// When Alice calls `Context::open`, a session will be created, but Bob will not yet have
     /// received this session. They will have to successfully complete a handshake first.
     ///
@@ -164,4 +167,5 @@ pub enum SessionEvent {
     Data,
     /// The received packet was some authentic protocol control packet. No action needs to be taken.
     Control,
+    DowngradedRatchetKey,
 }
diff --git a/src/zeta.rs b/src/zeta.rs
index 5649a59..3b077fb 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -580,7 +580,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     n: &[u8; AES_GCM_NONCE_SIZE],
     x2: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) -> Result<(), ReceiveError<App::StorageError>> {
+) -> Result<bool, ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    <- e, ee, ekem1, psk
     //    -> s, se
@@ -600,6 +600,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
     if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_NONCE_SIZE - 3..] != &x2[x2.len() - 3..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
+    let mut should_warn_missing_ratchet = false;
     let mut result = (|| {
         let a1 = if let ZetaAutomata::A1(a1) = &state.beta {
             a1
@@ -672,7 +673,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             chain_len = 0;
             result = test_ratchet_key(&[0u8; RATCHET_SIZE]);
             if result.is_some() {
-                // TODO: add some kind of warning callback or signal.
+                should_warn_missing_ratchet = true;
             }
         }
 
@@ -768,7 +769,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         Ok(ref mut packet) => send(packet, Some(&session.state.read().unwrap().hk_send)),
         _ => {}
     }
-    result.map(|_| ())
+    result.map(|_| should_warn_missing_ratchet)
 }
 fn send_control<App: ApplicationLayer, const CAP: usize>(
     session: &Arc<Session<App>>,
@@ -800,7 +801,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     kid: NonZeroU32,
     x3: &mut [u8],
     send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) -> Result<Arc<Session<App>>, ReceiveError<App::StorageError>> {
+) -> Result<(Arc<Session<App>>, bool), ReceiveError<App::StorageError>> {
     use FaultType::*;
     //    -> s, se
     if x3.len() < HANDSHAKE_COMPLETION_MIN_SIZE {
@@ -868,9 +869,11 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         match result {
             Ok(rss) => {
                 let RatchetStates { state1, state2 } = rss.unwrap_or_default();
+                let mut should_warn_missing_ratchet = false;
+
                 if (&zeta.ratchet_state != &state1) & (Some(&zeta.ratchet_state) != state2.as_ref()) {
                     if !responder_disallows_downgrade && zeta.ratchet_state.fingerprint().is_none() {
-                        // TODO: add some kind of warning callback or signal.
+                        should_warn_missing_ratchet = true;
                     } else {
                         if !responder_silently_rejects {
                             send(&mut create_reject(), Some(&App::PrpEnc::new(&zeta.hk_send)))
@@ -963,7 +966,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                 send_control(&session, &state, PACKET_TYPE_KEY_CONFIRM, c1, send);
                 drop(state);
 
-                Ok(session)
+                Ok((session, should_warn_missing_ratchet))
             }
             Err(e) => Err(ReceiveError::StorageError(e)),
         }
@@ -1650,30 +1653,27 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
     ctx: &Arc<ContextInner<App>>,
     session: &Arc<Session<App>>,
     payload: &[u8],
-    mut send: impl FnMut(&[u8]) -> bool,
+    mut send: impl FnMut(&mut [u8]) -> bool,
     mtu_sized_buffer: &mut [u8],
 ) -> Result<(), SendError> {
     use SendError::*;
     let mtu = mtu_sized_buffer.len();
     if mtu < MIN_TRANSPORT_MTU {
-        return Err(InvalidParameter);
+        return Err(MtuTooSmall);
     }
 
     let state = session.state.read().unwrap();
-    if matches!(&state.beta, ZetaAutomata::Null) {
-        return Err(SessionExpired);
-    }
-    if !matches!(
-        &state.beta,
-        ZetaAutomata::S1 | ZetaAutomata::S2 | ZetaAutomata::R1 { .. } | ZetaAutomata::R2 { .. }
-    ) {
-        return Err(SessionNotEstablished);
-    }
     let (c, should_rekey) = get_counter(session, &state).ok_or(SessionExpired)?;
     let nonce = to_nonce(PACKET_TYPE_DATA, c);
 
     let key = state.key_ref(false);
-    let mut cipher = key.nk.as_ref().unwrap().start_enc(&nonce);
+    let kid_send = key.send.kid.ok_or(SessionNotEstablished)?.get().to_be_bytes();
+    let mut cipher = key.nk.as_ref().ok_or(SessionNotEstablished)?.start_enc(&nonce);
+
+    debug_assert!(matches!(
+        &state.beta,
+        ZetaAutomata::S1 | ZetaAutomata::S2 | ZetaAutomata::R1 { .. } | ZetaAutomata::R2 { .. }
+    ));
 
     let payload_mtu = mtu - HEADER_SIZE;
     debug_assert!(payload_mtu >= 4);
@@ -1683,7 +1683,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
     let fragment_size_remainder = tagged_payload_len % fragment_count;
 
     let mut header = [0u8; HEADER_SIZE];
-    header[..KID_SIZE].copy_from_slice(&key.send.kid.unwrap().get().to_be_bytes());
+    header[..KID_SIZE].copy_from_slice(&kid_send);
     header[FRAGMENT_COUNT_IDX] = fragment_count as u8;
     header[PACKET_NONCE_START..].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
 
@@ -1705,7 +1705,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
                 .unwrap(),
         );
 
-        if !send(&mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
+        if !send(&mut mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
             return Ok(());
         }
         i = j;
@@ -1729,7 +1729,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
             .unwrap(),
     );
 
-    if !send(&mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
+    if !send(&mut mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
         return Ok(());
     }
 
diff --git a/src/zssp.rs b/src/zssp.rs
index 95a2398..92dbd63 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -338,7 +338,7 @@ impl<App: ApplicationLayer> Context<App> {
                     match packet_type {
                         PACKET_TYPE_HANDSHAKE_RESPONSE => {
                             log!(app, ReceivedRawX2);
-                            received_x2_trans(
+                            let should_warn_missing_ratchet = received_x2_trans(
                                 &app,
                                 ctx,
                                 &session,
@@ -348,11 +348,15 @@ impl<App: ApplicationLayer> Context<App> {
                                 send_associated,
                             )?;
                             log!(app, X2IsAuthSentX3(&session));
-                            SessionEvent::Control
+                            if should_warn_missing_ratchet {
+                                SessionEvent::DowngradedRatchetKey
+                            } else {
+                                SessionEvent::Control
+                            }
                         }
                         PACKET_TYPE_KEY_CONFIRM => {
                             log!(app, ReceivedRawKeyConfirm);
-                            let result = received_c1_trans(
+                            let just_established = received_c1_trans(
                                 &app,
                                 ctx,
                                 &session,
@@ -362,7 +366,7 @@ impl<App: ApplicationLayer> Context<App> {
                                 send_associated,
                             )?;
                             log!(app, KeyConfirmIsAuthSentAck(&session));
-                            if result {
+                            if just_established {
                                 SessionEvent::Established
                             } else {
                                 SessionEvent::Control
@@ -466,11 +470,19 @@ impl<App: ApplicationLayer> Context<App> {
                     }
 
                     log!(app, ReceivedRawX3);
-                    let session = received_x3_trans(&app, ctx, zeta, kid_recv, assembled_packet, |packet, hk_send| {
-                        send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
-                    })?;
+                    let (session, should_warn_missing_ratchet) =
+                        received_x3_trans(&app, ctx, zeta, kid_recv, assembled_packet, |packet, hk_send| {
+                            send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
+                        })?;
                     log!(app, X3IsAuthSentKeyConfirm(&session));
-                    Ok(ReceiveOk::Session(session, SessionEvent::NewSession))
+                    Ok(ReceiveOk::Session(
+                        session,
+                        if should_warn_missing_ratchet {
+                            SessionEvent::NewDowngradedSession
+                        } else {
+                            SessionEvent::NewSession
+                        },
+                    ))
                 } else {
                     // This can occur naturally because either Bob's incoming_sessions cache got
                     // full so Alice's incoming session was dropped, or the session this packet
@@ -604,7 +616,7 @@ impl<App: ApplicationLayer> Context<App> {
     pub fn send(
         &self,
         session: &Arc<Session<App>>,
-        send: impl FnMut(&[u8]) -> bool,
+        send: impl FnMut(&mut [u8]) -> bool,
         mtu_sized_buffer: &mut [u8],
         data: &[u8],
     ) -> Result<(), SendError> {

From ac9d97f0c3b7610a11de52de281f11fba51ad094 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 9 Aug 2023 12:08:16 -0400
Subject: [PATCH 30/50] switched kids to ne bytes

---
 src/challenge.rs   |   4 +-
 src/crypto/p384.rs |   4 +-
 src/zeta.rs        | 227 +++++++++++++++++++++++----------------------
 src/zssp.rs        |   7 +-
 4 files changed, 120 insertions(+), 122 deletions(-)

diff --git a/src/challenge.rs b/src/challenge.rs
index faabbce..09b14d4 100644
--- a/src/challenge.rs
+++ b/src/challenge.rs
@@ -16,7 +16,7 @@ pub struct ChallengeContext {
 /// Corresponds to Algorithm 11 found in Section 5.
 pub fn gen_null_response(rng: &mut impl RngCore) -> [u8; CHALLENGE_SIZE] {
     let mut response = [0u8; CHALLENGE_SIZE];
-    response[POW_START..].copy_from_slice(&rng.next_u64().to_be_bytes());
+    response[POW_START..].copy_from_slice(&rng.next_u64().to_ne_bytes());
     response
 }
 /// Corresponds to Algorithm 13 found in Section 5.
@@ -31,7 +31,7 @@ pub fn respond_to_challenge_in_place(
         let mut pow = rng.next_u64();
         let mut work_buf = [0u8; SHA512_HASH_SIZE];
         loop {
-            pre_response[POW_START..].copy_from_slice(&pow.to_be_bytes());
+            pre_response[POW_START..].copy_from_slice(&pow.to_ne_bytes());
             if verify_pow(hash, pre_response, &mut work_buf) {
                 return;
             }
diff --git a/src/crypto/p384.rs b/src/crypto/p384.rs
index 647ac93..67f780a 100644
--- a/src/crypto/p384.rs
+++ b/src/crypto/p384.rs
@@ -35,9 +35,9 @@ pub trait P384KeyPair<Rng: RngCore + CryptoRng> {
     /// This must output the compressed SEC1 NIST encoding of P-384 public keys.
     fn public_key_bytes(&self) -> [u8; P384_PUBLIC_KEY_SIZE];
 
-    /// Perform ECDH key agreement, writing the raw (un-hashed!) ECDH secret to `output`.
+    /// Perform ECDH key agreement, writing the raw (un-hashed!) ECDH secret to `ecdh_out`.
     ///
-    /// **CRITICAL**: This function must return `None` if key agreement between this private key and
+    /// **CRITICAL**: This function must return `false` if key agreement between this private key and
     /// the input `public_key` key would result in an invalid, non-standard or predictable ECDH secret.
     /// Please refer to the NIST spec for P-384 ECDH key agreement, or better yet use a peer reviewed
     /// library that has already implemented this correctly.
diff --git a/src/zeta.rs b/src/zeta.rs
index 3b077fb..f824eb0 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -23,58 +23,6 @@ use crate::zssp::{log, ContextInner, SessionQueue};
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
 
-/// Create a 96-bit AES-GCM nonce.
-///
-/// The primary information that we want to be contained here is the counter and the
-/// packet type. The former makes this unique and the latter's inclusion authenticates
-/// it as effectively AAD. Other elements of the header are either not authenticated,
-/// like fragmentation info, or their authentication is implied via key exchange like
-/// the key id.
-///
-/// Corresponds to Figure 10 found in Section 4.3.
-pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_NONCE_SIZE] {
-    let mut ret = [0u8; AES_GCM_NONCE_SIZE];
-    ret[3] = packet_type;
-    // Noise requires a big endian counter at the end of the Nonce
-    ret[4..].copy_from_slice(&counter.to_be_bytes());
-    ret
-}
-/// Corresponds to Figure 10 and Figure 14 found in Section 4.3.
-pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
-    assert!(n.len() >= PACKET_NONCE_SIZE);
-    let c_start = n.len() - 8;
-    (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
-}
-fn create_ratchet_state<App: ApplicationLayer>(
-    hmac: &mut App::Hmac,
-    noise: &SymmetricState<App>,
-    pre_chain_len: u64,
-) -> RatchetState {
-    let mut rk = Zeroizing::new([0u8; HASHLEN]);
-    let mut rf = Zeroizing::new([0u8; HASHLEN]);
-    noise.get_ask(hmac, LABEL_RATCHET_STATE, &mut rk, &mut rf);
-    RatchetState::new(
-        Zeroizing::new(rk[..RATCHET_SIZE].try_into().unwrap()),
-        Zeroizing::new(rf[..RATCHET_SIZE].try_into().unwrap()),
-        pre_chain_len + 1,
-    )
-}
-fn get_counter<App: ApplicationLayer>(session: &Session<App>, state: &MutableState<App>) -> Option<(u64, bool)> {
-    if session.session_has_expired.load(Ordering::Relaxed) {
-        None
-    } else {
-        let c = session.send_counter.fetch_add(1, Ordering::Relaxed);
-        if c > THREAD_SAFE_COUNTER_HARD_EXPIRE {
-            session.session_has_expired.store(true, Ordering::SeqCst);
-        }
-        if c > state.key_creation_counter + EXPIRE_AFTER_USES {
-            session.session_has_expired.store(true, Ordering::SeqCst);
-            return None;
-        }
-        Some((c, c > state.key_creation_counter + App::SETTINGS.rekey_after_key_uses))
-    }
-}
-
 /// Corresponds to the Zeta State Machine found in Section 4.1.
 pub struct Session<App: ApplicationLayer> {
     ctx: Weak<ContextInner<App>>,
@@ -131,34 +79,12 @@ pub(crate) struct DuplexKey<App: ApplicationLayer> {
     recv: Keys,
     nk: Option<App::AeadPool>,
 }
-impl<App: ApplicationLayer> Default for DuplexKey<App> {
-    fn default() -> Self {
-        Self { send: Default::default(), recv: Default::default(), nk: None }
-    }
-}
-impl<App: ApplicationLayer> DuplexKey<App> {
-    fn replace_nk(&mut self, nk_send: &[u8; HASHLEN], nk_recv: &[u8; HASHLEN]) {
-        self.nk = Some(App::AeadPool::new(
-            (&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap(),
-            (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap(),
-        ))
-    }
-}
 
 #[derive(Default)]
 pub(crate) struct Keys {
     kek: Option<Zeroizing<[u8; AES_256_KEY_SIZE]>>,
     kid: Option<NonZeroU32>,
 }
-impl Keys {
-    fn replace_kek(&mut self, kek: &[u8; HASHLEN]) {
-        // We want to give rust the best chance of implementing this in a way that does
-        // not leak the key on the stack.
-        self.kek
-            .get_or_insert(Zeroizing::new([0u8; AES_256_KEY_SIZE]))
-            .copy_from_slice(&kek[..AES_256_KEY_SIZE]);
-    }
-}
 
 /// Corresponds to State A_1 of the Zeta State Machine found in Section 4.1.
 #[derive(Clone)]
@@ -192,6 +118,38 @@ pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
     },
 }
 
+impl<App: ApplicationLayer> Default for DuplexKey<App> {
+    fn default() -> Self {
+        Self { send: Default::default(), recv: Default::default(), nk: None }
+    }
+}
+impl<App: ApplicationLayer> DuplexKey<App> {
+    fn replace_nk(&mut self, nk_send: &[u8; HASHLEN], nk_recv: &[u8; HASHLEN]) {
+        self.nk = Some(App::AeadPool::new(
+            (&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap(),
+            (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap(),
+        ))
+    }
+}
+impl Keys {
+    fn replace_kek(&mut self, kek: &[u8; HASHLEN]) {
+        // We want to give rust the best chance of implementing this in a way that does
+        // not leak the key on the stack.
+        self.kek
+            .get_or_insert(Zeroizing::new([0u8; AES_256_KEY_SIZE]))
+            .copy_from_slice(&kek[..AES_256_KEY_SIZE]);
+    }
+}
+
+impl<App: ApplicationLayer> MutableState<App> {
+    fn key_ref(&self, is_next: bool) -> &DuplexKey<App> {
+        &self.keys[(self.key_index ^ is_next) as usize]
+    }
+    fn key_mut(&mut self, is_next: bool) -> &mut DuplexKey<App> {
+        &mut self.keys[(self.key_index ^ is_next) as usize]
+    }
+}
+
 impl<App: ApplicationLayer> SymmetricState<App> {
     fn write_e_no_init<const CAP: usize>(
         &mut self,
@@ -241,6 +199,62 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
 }
 
+/// Create a 96-bit AES-GCM nonce.
+///
+/// The primary information that we want to be contained here is the counter and the
+/// packet type. The former makes this unique and the latter's inclusion authenticates
+/// it as effectively AAD. Other elements of the header are either not authenticated,
+/// like fragmentation info, or their authentication is implied via key exchange like
+/// the key id.
+///
+/// Corresponds to Figure 10 found in Section 4.3.
+pub(crate) fn to_nonce(packet_type: u8, counter: u64) -> [u8; AES_GCM_NONCE_SIZE] {
+    let mut ret = [0u8; AES_GCM_NONCE_SIZE];
+    ret[3] = packet_type;
+    // Noise requires a big endian counter at the end of the Nonce
+    ret[4..].copy_from_slice(&counter.to_be_bytes());
+    ret
+}
+/// Corresponds to Figure 10 and Figure 14 found in Section 4.3.
+pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
+    assert!(n.len() >= PACKET_NONCE_SIZE);
+    let c_start = n.len() - 8;
+    (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
+}
+fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_NONCE_SIZE]) {
+    packet[..KID_SIZE].copy_from_slice(&kid_send.to_ne_bytes());
+    packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
+}
+fn create_ratchet_state<App: ApplicationLayer>(
+    hmac: &mut App::Hmac,
+    noise: &SymmetricState<App>,
+    pre_chain_len: u64,
+) -> RatchetState {
+    let mut rk = Zeroizing::new([0u8; HASHLEN]);
+    let mut rf = Zeroizing::new([0u8; HASHLEN]);
+    noise.get_ask(hmac, LABEL_RATCHET_STATE, &mut rk, &mut rf);
+    RatchetState::new(
+        Zeroizing::new(rk[..RATCHET_SIZE].try_into().unwrap()),
+        Zeroizing::new(rf[..RATCHET_SIZE].try_into().unwrap()),
+        pre_chain_len + 1,
+    )
+}
+fn get_counter<App: ApplicationLayer>(session: &Session<App>, state: &MutableState<App>) -> Option<(u64, bool)> {
+    if session.session_has_expired.load(Ordering::Relaxed) {
+        None
+    } else {
+        let c = session.send_counter.fetch_add(1, Ordering::Relaxed);
+        if c > THREAD_SAFE_COUNTER_HARD_EXPIRE {
+            session.session_has_expired.store(true, Ordering::SeqCst);
+        }
+        if c > state.key_creation_counter + EXPIRE_AFTER_USES {
+            session.session_has_expired.store(true, Ordering::SeqCst);
+            return None;
+        }
+        Some((c, c > state.key_creation_counter + App::SETTINGS.rekey_after_key_uses))
+    }
+}
+
 /// Generate a random local key id that is currently unused.
 fn gen_kid<T>(session_map: &HashMap<NonZeroU32, T>, rng: &mut impl RngCore) -> NonZeroU32 {
     loop {
@@ -251,19 +265,20 @@ fn gen_kid<T>(session_map: &HashMap<NonZeroU32, T>, rng: &mut impl RngCore) -> N
         }
     }
 }
-
-impl<App: ApplicationLayer> MutableState<App> {
-    fn key_ref(&self, is_next: bool) -> &DuplexKey<App> {
-        &self.keys[(self.key_index ^ is_next) as usize]
-    }
-    fn key_mut(&mut self, is_next: bool) -> &mut DuplexKey<App> {
-        &mut self.keys[(self.key_index ^ is_next) as usize]
-    }
-}
-
-fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_NONCE_SIZE]) {
-    packet[..KID_SIZE].copy_from_slice(&kid_send.to_be_bytes());
-    packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
+fn remap<App: ApplicationLayer>(
+    ctx: &Arc<ContextInner<App>>,
+    session: &Arc<Session<App>>,
+    state: &MutableState<App>,
+) -> NonZeroU32 {
+    let mut session_map = ctx.session_map.write().unwrap();
+    let weak = if let Some(Some(weak)) = state.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
+        weak
+    } else {
+        Arc::downgrade(&session)
+    };
+    let new_kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
+    session_map.insert(new_kid_recv, weak);
+    new_kid_recv
 }
 
 fn create_a1_state<App: ApplicationLayer>(
@@ -283,7 +298,7 @@ fn create_a1_state<App: ApplicationLayer>(
     let mut x1 = ArrayVec::<u8, HEADERED_HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE>::new();
     x1.extend([0u8; HEADER_SIZE]);
     // Noise process prologue.
-    let kid = kid_recv.get().to_be_bytes();
+    let kid = kid_recv.get().to_ne_bytes();
     x1.extend(kid);
     noise.mix_hash(hash, &kid);
     noise.mix_hash(hash, &s_remote.to_bytes());
@@ -450,7 +465,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     // Noise process prologue.
     let j = i + KID_SIZE;
     noise.mix_hash(hash, &x1[i..j]);
-    let kid_send = NonZeroU32::new(u32::from_be_bytes(x1[i..j].try_into().unwrap()))
+    let kid_send = NonZeroU32::new(u32::from_ne_bytes(x1[i..j].try_into().unwrap()))
         .ok_or(byzantine_fault!(InvalidPacket, true))?;
     noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
     i = j;
@@ -537,12 +552,12 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     );
 
     let i = x2.len();
-    x2.extend(kid_recv.get().to_be_bytes());
+    x2.extend(kid_recv.get().to_ne_bytes());
     let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]);
     x2.extend(tag);
 
     let i = x2.len();
-    let mut c = 0u64.to_be_bytes();
+    let mut c = [0u8; 8];
     c[5] = x2[i - 3];
     c[6] = x2[i - 2];
     c[7] = x2[i - 1];
@@ -654,7 +669,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut payload, tag) {
                 return None;
             }
-            NonZeroU32::new(u32::from_be_bytes(payload)).map(|kid2| (kid2, noise))
+            NonZeroU32::new(u32::from_ne_bytes(payload)).map(|kid2| (kid2, noise))
         };
         // Check first key.
         let mut ratchet_i = 1;
@@ -1248,7 +1263,7 @@ fn timeout_trans<App: ApplicationLayer>(
             noise.mix_key(hmac, session.noise_kk_ss.as_ref());
             // Process message pattern 1 payload.
             let i = k1.len();
-            k1.extend(new_kid_recv.get().to_be_bytes());
+            k1.extend(new_kid_recv.get().to_ne_bytes());
             let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..]);
             k1.extend(tag);
 
@@ -1337,21 +1352,6 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
         }
     }
 }
-fn remap<App: ApplicationLayer>(
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
-    state: &MutableState<App>,
-) -> NonZeroU32 {
-    let mut session_map = ctx.session_map.write().unwrap();
-    let weak = if let Some(Some(weak)) = state.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
-        weak
-    } else {
-        Arc::downgrade(&session)
-    };
-    let new_kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
-    session_map.insert(new_kid_recv, weak);
-    new_kid_recv
-}
 /// Corresponds to Transition Algorithm 7 found in Section 4.3.
 pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     app: &App,
@@ -1432,7 +1432,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..j], tag) {
             return Err(byzantine_fault!(FailedAuth, true));
         }
-        let kid_send = NonZeroU32::new(u32::from_be_bytes(k1[i..j].try_into().unwrap()))
+        let kid_send = NonZeroU32::new(u32::from_ne_bytes(k1[i..j].try_into().unwrap()))
             .ok_or(byzantine_fault!(FailedAuth, true))?;
 
         let mut k2 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
@@ -1450,7 +1450,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
         // Process message pattern 2 payload.
         let i = k2.len();
         let new_kid_recv = remap(ctx, session, &state);
-        k2.extend(new_kid_recv.get().to_be_bytes());
+        k2.extend(new_kid_recv.get().to_ne_bytes());
         let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..]);
         k2.extend(tag);
 
@@ -1582,7 +1582,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
             if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..j], tag) {
                 return Err(byzantine_fault!(FailedAuth, true));
             }
-            let kid_send = NonZeroU32::new(u32::from_be_bytes(k2[i..j].try_into().unwrap()))
+            let kid_send = NonZeroU32::new(u32::from_ne_bytes(k2[i..j].try_into().unwrap()))
                 .ok_or(byzantine_fault!(InvalidPacket, true))?;
 
             let new_ratchet_state = create_ratchet_state(hmac, &noise, state.ratchet_state1.chain_len);
@@ -1667,7 +1667,7 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
     let nonce = to_nonce(PACKET_TYPE_DATA, c);
 
     let key = state.key_ref(false);
-    let kid_send = key.send.kid.ok_or(SessionNotEstablished)?.get().to_be_bytes();
+    let kid_send = key.send.kid.ok_or(SessionNotEstablished)?.get().to_ne_bytes();
     let mut cipher = key.nk.as_ref().ok_or(SessionNotEstablished)?.start_enc(&nonce);
 
     debug_assert!(matches!(
@@ -1763,7 +1763,8 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
     } else if Some(kid) == state.keys[1].recv.kid {
         state.keys[1].nk.as_ref()
     } else {
-        return Err(byzantine_fault!(OutOfSequence, true));
+        // Should be unreachable unless we are leaking kids somewhere.
+        return Err(byzantine_fault!(UnknownLocalKeyId, true));
     };
 
     let mut cipher = specified_key
diff --git a/src/zssp.rs b/src/zssp.rs
index 92dbd63..0acc741 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -219,11 +219,9 @@ impl<App: ApplicationLayer> Context<App> {
         let mut fragment_buffer = Assembled::new();
 
         let kid_recv = incoming_fragment[0..KID_SIZE].try_into().unwrap();
-        if let Some(kid_recv) = NonZeroU32::new(u32::from_be_bytes(kid_recv)) {
-            let session_map = self.0.session_map.read().unwrap();
+        if let Some(kid_recv) = NonZeroU32::new(u32::from_ne_bytes(kid_recv)) {
             let session = ctx.session_map.read().unwrap().get(&kid_recv).map(|r| r.upgrade());
             if let Some(Some(session)) = session {
-                drop(session_map);
                 let state = session.state.read().unwrap();
                 state.hk_recv.decrypt_in_place(
                     (&mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
@@ -417,7 +415,6 @@ impl<App: ApplicationLayer> Context<App> {
                 };
                 Ok(ReceiveOk::Session(session, ret))
             } else {
-                drop(session_map);
                 // Check for and handle PACKET_TYPE_ALICE_NOISE_XK_PATTERN_3
                 let zeta = self.0.unassociated_handshake_states.get(kid_recv);
                 if let Some(zeta) = zeta {
@@ -591,7 +588,7 @@ impl<App: ApplicationLayer> Context<App> {
                     return Err(byzantine_fault!(InvalidPacket, true));
                 }
                 if let Some(kid_recv) =
-                    NonZeroU32::new(u32::from_be_bytes(assembled_packet[..KID_SIZE].try_into().unwrap()))
+                    NonZeroU32::new(u32::from_ne_bytes(assembled_packet[..KID_SIZE].try_into().unwrap()))
                 {
                     if let Some(Some(session)) = ctx.session_map.read().unwrap().get(&kid_recv).map(|r| r.upgrade()) {
                         respond_to_challenge(ctx, &session, &assembled_packet[KID_SIZE..].try_into().unwrap());

From 9d9091f6556e78404fe0644da3953f2258c0eaa6 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 11:05:33 -0400
Subject: [PATCH 31/50] refactored crypto

---
 examples/basic_test.rs |  47 ++---
 src/application.rs     |  45 ++---
 src/handshake_cache.rs |  10 +-
 src/log_event.rs       |  44 ++---
 src/result.rs          |  14 +-
 src/symmetric_state.rs |  34 ++--
 src/zeta.rs            | 421 +++++++++++++++++++++--------------------
 src/zssp.rs            |  84 ++++----
 8 files changed, 352 insertions(+), 347 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 3bbf1f0..f90a764 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -10,8 +10,8 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 
 use zssp::application::{
-    AcceptAction, ApplicationLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate, Settings,
-    RATCHET_SIZE,
+    AcceptAction, CryptoLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate, Settings,
+    RATCHET_SIZE, ApplicationLayer,
 };
 use zssp::crypto::P384KeyPair;
 use zssp::crypto_impl::*;
@@ -37,7 +37,7 @@ impl Ratchets {
 }
 
 #[allow(unused)]
-impl ApplicationLayer for &TestApplication {
+impl CryptoLayer for TestApplication {
     const SETTINGS: Settings = Settings {
         initial_offer_timeout: Settings::INITIAL_OFFER_TIMEOUT_MS,
         rekey_timeout: 60 * 1000,
@@ -59,24 +59,27 @@ impl ApplicationLayer for &TestApplication {
     type KeyPair = P384CrateKeyPair;
     type Kem = RustKyber1024PrivateKey;
 
-    type StorageError = std::convert::Infallible;
     type SessionData = u128;
 
     type IncomingPacketBuffer = Vec<u8>;
+}
+#[allow(unused)]
+impl ApplicationLayer for &TestApplication {
+    type Crypto = TestApplication;
 
-    fn incoming_session(&self) -> IncomingSessionAction {
+    fn incoming_session(&mut self) -> IncomingSessionAction {
         IncomingSessionAction::Allow
     }
 
-    fn hello_requires_recognized_ratchet(&self) -> bool {
+    fn hello_requires_recognized_ratchet(&mut self) -> bool {
         false
     }
 
-    fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>) -> bool {
+    fn initiator_disallows_downgrade(&mut self, session: &Arc<Session<TestApplication>>) -> bool {
         true
     }
 
-    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self> {
+    fn check_accept_session(&mut self, remote_static_key: &P384CratePublicKey, identity: &[u8]) -> AcceptAction<TestApplication> {
         AcceptAction {
             session_data: Some(1),
             responder_disallows_downgrade: true,
@@ -85,28 +88,28 @@ impl ApplicationLayer for &TestApplication {
     }
 
     fn restore_by_fingerprint(
-        &self,
+        &mut self,
         ratchet_fingerprint: &[u8; RATCHET_SIZE],
-    ) -> Result<Option<RatchetState>, Self::StorageError> {
+    ) -> Result<Option<RatchetState>, ()> {
         let ratchets = self.ratchets.lock().unwrap();
         Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
     }
 
     fn restore_by_identity(
-        &self,
-        remote_static_key: &Self::PublicKey,
-        session_data: &Self::SessionData,
-    ) -> Result<Option<RatchetStates>, Self::StorageError> {
+        &mut self,
+        remote_static_key: &P384CratePublicKey,
+        session_data: &u128,
+    ) -> Result<Option<RatchetStates>, ()> {
         let ratchets = self.ratchets.lock().unwrap();
         Ok(ratchets.peer_map.get(session_data).cloned())
     }
 
     fn save_ratchet_state(
-        &self,
-        remote_static_key: &Self::PublicKey,
-        session_data: &Self::SessionData,
+        &mut self,
+        remote_static_key: &P384CratePublicKey,
+        session_data: &u128,
         update_data: RatchetUpdate<'_>,
-    ) -> Result<(), Self::StorageError> {
+    ) -> Result<(), ()> {
         let mut ratchets = self.ratchets.lock().unwrap();
         ratchets.peer_map.insert(*session_data, update_data.to_states());
 
@@ -123,11 +126,11 @@ impl ApplicationLayer for &TestApplication {
         Ok(())
     }
 
-    fn time(&self) -> i64 {
+    fn time(&mut self) -> i64 {
         self.time.elapsed().as_millis() as i64
     }
 
-    fn event_log(&self, event: zssp::LogEvent<Self>) {
+    fn event_log(&mut self, event: zssp::LogEvent<TestApplication>) {
         println!(">[{}] {:?}", self.name, event);
     }
 }
@@ -144,7 +147,7 @@ fn alice_main(
     bob_pubkey: P384CratePublicKey,
 ) {
     let startup_time = std::time::Instant::now();
-    let context = zssp::Context::<&TestApplication>::new(alice_keypair, OsRng);
+    let context = zssp::Context::<TestApplication>::new(alice_keypair, OsRng);
     let mut next_service = startup_time.elapsed().as_millis() as i64 + 500;
     let test_data = [1u8; TEST_MTU * 10];
     let mut up = false;
@@ -250,7 +253,7 @@ fn bob_main(
     bob_keypair: P384CrateKeyPair,
 ) {
     let startup_time = std::time::Instant::now();
-    let context = zssp::Context::<&TestApplication>::new(bob_keypair, OsRng);
+    let context = zssp::Context::<TestApplication>::new(bob_keypair, OsRng);
     let mut last_speed_metric = startup_time.elapsed().as_millis() as i64;
     let mut next_service = last_speed_metric + 500;
     let mut transferred = 0u64;
diff --git a/src/application.rs b/src/application.rs
index d05aeb8..05bb201 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -90,7 +90,7 @@ impl Default for Settings {
 /// and negotiation timeout behavior. Both sides of a ZSSP session **must** have these constants
 /// set to the same values. Changing these constants is generally discouraged unless you know
 /// what you are doing.
-pub trait ApplicationLayer: Sized {
+pub trait CryptoLayer: Sized {
     /// These are constants that can be redefined from their defaults to change rekey
     /// and negotiation timeout behavior. If two sides of a ZSSP session have different constants,
     /// the protocol will tend to default to the smaller constants.
@@ -129,9 +129,6 @@ pub trait ApplicationLayer: Sized {
     /// for ZSSP to achieve FIPS compliance.
     type Kem: Kyber1024PrivateKey<Self::Rng>;
 
-    /// A user-defined error returned when the `ApplicationLayer` fails to access persistent storage
-    /// for a peer's ratchet states.
-    type StorageError: std::error::Error;
 
     /// Type for arbitrary opaque object for use by the application that is attached to
     /// each session.
@@ -144,14 +141,18 @@ pub trait ApplicationLayer: Sized {
     /// hold these for a short period of time when assembling fragmented packets on the receive
     /// path.
     type IncomingPacketBuffer: AsRef<[u8]> + AsMut<[u8]>;
+}
+
+pub trait ApplicationLayer: Sized {
+    type Crypto: CryptoLayer;
 
     /// Should return the current time in milliseconds. Does not have to be monotonic, nor synced
     /// with remote peers (although both of these properties would help reliability slightly).
     /// Used to determine if any current handshakes should be resent or timed-out, or if a session
     /// should rekey.
-    fn time(&self) -> i64;
+    fn time(&mut self) -> i64;
 
-    fn incoming_session(&self) -> IncomingSessionAction;
+    fn incoming_session(&mut self) -> IncomingSessionAction;
     /// This function will be called whenever Alice's initial Hello packet contains the empty ratchet
     /// fingerprint. Brand new peers will always connect to Bob with the empty ratchet, but from
     /// then on they should be using non-empty ratchet states.
@@ -161,7 +162,7 @@ pub trait ApplicationLayer: Sized {
     /// If this function is configured to always return true, it means peers will not be able to
     /// connect to us unless they had a prior-established ratchet key with us. This is the best way
     /// for the paranoid to enforce a manual allow-list.
-    fn hello_requires_recognized_ratchet(&self) -> bool;
+    fn hello_requires_recognized_ratchet(&mut self) -> bool;
     /// This function is called if we, as Alice, attempted to open a session with Bob using a
     /// non-empty ratchet key, but Bob does not have this ratchet key and wants to downgrade
     /// to the zero ratchet key.
@@ -177,14 +178,14 @@ pub trait ApplicationLayer: Sized {
     /// least one party is misconfigured and got their ratchet keys corrupted or lost, or Bob has
     /// been compromised and is being impersonated. An attacker must at least have Bob's private
     /// static key to be able to ask Alice to downgrade.
-    fn initiator_disallows_downgrade(&self, session: &Arc<Session<Self>>) -> bool;
+    fn initiator_disallows_downgrade(&mut self, session: &Arc<Session<Self::Crypto>>) -> bool;
     /// Function to accept sessions after final negotiation.
     /// The second argument is the identity that the remote peer sent us. The application
     /// must verify this identity is associated with the remote peer's static key.
     /// To prevent desync, if this function specifies that we should connect, no other open session
     /// with the same remote peer must exist. Drop or call expire on any pre-existing sessions
     /// before returning.
-    fn check_accept_session(&self, remote_static_key: &Self::PublicKey, identity: &[u8]) -> AcceptAction<Self>;
+    fn check_accept_session(&mut self, remote_static_key: &<Self::Crypto as CryptoLayer>::PublicKey, identity: &[u8]) -> AcceptAction<Self::Crypto>;
 
     /// Lookup a specific ratchet state based on its ratchet fingerprint.
     /// This function will be called whenever Alice attempts to connect to us with a non-empty
@@ -193,9 +194,9 @@ pub trait ApplicationLayer: Sized {
     /// If a ratchet state with a matching fingerprint could not be found, this function should
     /// return `Ok(None)`.
     fn restore_by_fingerprint(
-        &self,
+        &mut self,
         ratchet_fingerprint: &[u8; RATCHET_SIZE],
-    ) -> Result<Option<RatchetState>, Self::StorageError>;
+    ) -> Result<Option<RatchetState>, ()>;
     /// Lookup the specific ratchet states based on the identity of the peer being communicated with.
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
@@ -211,10 +212,10 @@ pub trait ApplicationLayer: Sized {
     /// Filtering peers should be done by the caller to `Context::open` as well as by the
     /// function `ApplicationLayer::check_accept_session`.
     fn restore_by_identity(
-        &self,
-        remote_static_key: &Self::PublicKey,
-        session_data: &Self::SessionData,
-    ) -> Result<Option<RatchetStates>, Self::StorageError>;
+        &mut self,
+        remote_static_key: &<Self::Crypto as CryptoLayer>::PublicKey,
+        session_data: &<Self::Crypto as CryptoLayer>::SessionData,
+    ) -> Result<Option<RatchetStates>, ()>;
     /// Atomically commit the update specified by `update_data` to storage, or return an error if
     /// the update could not be made.
     /// The implementor is free to choose how to apply these updates to storage.
@@ -232,17 +233,17 @@ pub trait ApplicationLayer: Sized {
     /// to us will have to allow downgrade across the board.
     /// Otherwise, when we restart, we will not be allowed to reconnect.
     fn save_ratchet_state(
-        &self,
-        remote_static_key: &Self::PublicKey,
-        session_data: &Self::SessionData,
+        &mut self,
+        remote_static_key: &<Self::Crypto as CryptoLayer>::PublicKey,
+        session_data: &<Self::Crypto as CryptoLayer>::SessionData,
         update_data: RatchetUpdate<'_>,
-    ) -> Result<(), Self::StorageError>;
+    ) -> Result<(), ()>;
 
     /// Receives a stream of events that occur during an execution of ZSSP.
     /// These are provided for debugging, logging or metrics purposes, and must be used for
     /// nothing else. Do not base protocol-level decisions upon the events passed to this function.
     #[cfg(feature = "logging")]
-    fn event_log(&self, event: crate::LogEvent<'_, Self>);
+    fn event_log(&mut self, event: crate::LogEvent<'_, Self::Crypto>);
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -256,10 +257,10 @@ pub enum IncomingSessionAction {
 /// used by Bob, the responder, at the very last stage of the key exchange.
 ///
 /// Corresponds to the *Accept* callback of Transition Algorithm 4.
-pub struct AcceptAction<App: ApplicationLayer> {
+pub struct AcceptAction<Crypto: CryptoLayer> {
     /// The data object to be attached to the session if we successfully connect.
     /// If this field is None then we will not connect to this remote peer.
-    pub session_data: Option<App::SessionData>,
+    pub session_data: Option<Crypto::SessionData>,
     /// Whether or not we will accept a connection with the remote peer when they do not have a
     /// ratchet key that we think they should have.
     pub responder_disallows_downgrade: bool,
diff --git a/src/handshake_cache.rs b/src/handshake_cache.rs
index 3939cc7..1425a9b 100644
--- a/src/handshake_cache.rs
+++ b/src/handshake_cache.rs
@@ -3,23 +3,23 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock};
 
 use crate::zeta::StateB2;
-use crate::{application::ApplicationLayer, proto::MAX_UNASSOCIATED_HANDSHAKE_STATES};
+use crate::{application::CryptoLayer, proto::MAX_UNASSOCIATED_HANDSHAKE_STATES};
 
-pub(crate) struct UnassociatedHandshakeCache<Application: ApplicationLayer> {
+pub(crate) struct UnassociatedHandshakeCache<Application: CryptoLayer> {
     has_pending: AtomicBool, // Allowed to be falsely positive
     cache: RwLock<CacheInner<Application>>,
 }
 /// SoA format
-struct CacheInner<App: ApplicationLayer> {
+struct CacheInner<Crypto: CryptoLayer> {
     local_ids: [Option<NonZeroU32>; MAX_UNASSOCIATED_HANDSHAKE_STATES],
     timeouts: [i64; MAX_UNASSOCIATED_HANDSHAKE_STATES],
-    handshakes: [Option<Arc<StateB2<App>>>; MAX_UNASSOCIATED_HANDSHAKE_STATES],
+    handshakes: [Option<Arc<StateB2<Crypto>>>; MAX_UNASSOCIATED_HANDSHAKE_STATES],
 }
 
 /// Linear-search cache for capping the memory consumption of handshake data.
 /// Designed specifically to have short and simple code that clearly bounds above
 /// memory consumption.
-impl<Application: ApplicationLayer> UnassociatedHandshakeCache<Application> {
+impl<Application: CryptoLayer> UnassociatedHandshakeCache<Application> {
     pub(crate) fn new() -> Self {
         Self {
             has_pending: AtomicBool::new(false),
diff --git a/src/log_event.rs b/src/log_event.rs
index 283ae3a..3671abd 100644
--- a/src/log_event.rs
+++ b/src/log_event.rs
@@ -1,22 +1,22 @@
 use std::sync::Arc;
 
-use crate::application::ApplicationLayer;
+use crate::application::CryptoLayer;
 use crate::zeta::Session;
 
 /// ZSSP events that might be interesting to log or aggregate into metrics.
-pub enum LogEvent<'a, App: ApplicationLayer> {
-    ResentX1(&'a Arc<Session<App>>),
-    TimeoutX1(&'a Arc<Session<App>>),
+pub enum LogEvent<'a, Crypto: CryptoLayer> {
+    ResentX1(&'a Arc<Session<Crypto>>),
+    TimeoutX1(&'a Arc<Session<Crypto>>),
     TimeoutX2,
-    ResentX3(&'a Arc<Session<App>>),
-    TimeoutX3(&'a Arc<Session<App>>),
-    ResentKeyConfirm(&'a Arc<Session<App>>),
-    TimeoutKeyConfirm(&'a Arc<Session<App>>),
-    StartedRekeyingSentK1(&'a Arc<Session<App>>),
-    ResentK1(&'a Arc<Session<App>>),
-    TimeoutK1(&'a Arc<Session<App>>),
-    ResentK2(&'a Arc<Session<App>>),
-    TimeoutK2(&'a Arc<Session<App>>),
+    ResentX3(&'a Arc<Session<Crypto>>),
+    TimeoutX3(&'a Arc<Session<Crypto>>),
+    ResentKeyConfirm(&'a Arc<Session<Crypto>>),
+    TimeoutKeyConfirm(&'a Arc<Session<Crypto>>),
+    StartedRekeyingSentK1(&'a Arc<Session<Crypto>>),
+    ResentK1(&'a Arc<Session<Crypto>>),
+    TimeoutK1(&'a Arc<Session<Crypto>>),
+    ResentK2(&'a Arc<Session<Crypto>>),
+    TimeoutK2(&'a Arc<Session<Crypto>>),
     /// `(packet_type, packet_counter, fragment_no, fragment_count)`
     ReceivedRawFragment(u8, u64, usize, usize),
     ReceivedRawX1,
@@ -24,24 +24,24 @@ pub enum LogEvent<'a, App: ApplicationLayer> {
     X1SucceededChallenge,
     X1IsAuthSentX2,
     ReceivedRawChallenge,
-    ChallengeIsAuth(&'a Arc<Session<App>>),
+    ChallengeIsAuth(&'a Arc<Session<Crypto>>),
     ReceivedRawX2,
-    X2IsAuthSentX3(&'a Arc<Session<App>>),
+    X2IsAuthSentX3(&'a Arc<Session<Crypto>>),
     ReceivedRawX3,
-    X3IsAuthSentKeyConfirm(&'a Arc<Session<App>>),
+    X3IsAuthSentKeyConfirm(&'a Arc<Session<Crypto>>),
     ReceivedRawKeyConfirm,
-    KeyConfirmIsAuthSentAck(&'a Arc<Session<App>>),
+    KeyConfirmIsAuthSentAck(&'a Arc<Session<Crypto>>),
     ReceivedRawAck,
-    AckIsAuth(&'a Arc<Session<App>>),
+    AckIsAuth(&'a Arc<Session<Crypto>>),
     ReceivedRawK1,
-    K1IsAuthSentK2(&'a Arc<Session<App>>),
+    K1IsAuthSentK2(&'a Arc<Session<Crypto>>),
     ReceivedRawK2,
-    K2IsAuthSentKeyConfirm(&'a Arc<Session<App>>),
+    K2IsAuthSentKeyConfirm(&'a Arc<Session<Crypto>>),
     ReceivedRawD,
-    DIsAuthClosedSession(&'a Arc<Session<App>>),
+    DIsAuthClosedSession(&'a Arc<Session<Crypto>>),
 }
 
-impl<'a, App: ApplicationLayer> std::fmt::Debug for LogEvent<'a, App> {
+impl<'a, Crypto: CryptoLayer> std::fmt::Debug for LogEvent<'a, Crypto> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::ResentX1(_) => f.debug_tuple("ResentX1").finish(),
diff --git a/src/result.rs b/src/result.rs
index 8c19d85..a972597 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -1,18 +1,18 @@
 use std::sync::Arc;
 
-use crate::application::ApplicationLayer;
+use crate::application::CryptoLayer;
 use crate::zeta::Session;
 
 /// An error that can occur when attempting to open a session.
 /// Depending on the error type trying again may not work.
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub enum OpenError<IoError> {
+pub enum OpenError {
     /// An invalid parameter was supplied to the function.
     InvalidPublicKey,
 
     IdentityTooLarge,
 
-    RatchetIoError(IoError),
+    RatchetStorageError,
 }
 
 /// An error that can occur when attempting to send data over a session.
@@ -64,7 +64,7 @@ pub enum FaultType {
 
 /// An error that occurred during the receipt of a given packet.
 #[derive(Debug)]
-pub enum ReceiveError<StorageError> {
+pub enum ReceiveError {
     /// A type of fault that can occur because a remote peer sent us a bad packet.
     /// Such packets will be ignored by ZSSP but a user of ZSSP might want to log
     /// them for debugging or tracing.
@@ -107,7 +107,7 @@ pub enum ReceiveError<StorageError> {
     Rejected,
     /// One of the ratchet saving or lookup functions returned an error, so the packet had to be
     /// dropped.
-    StorageError(StorageError),
+    RatchetStorageError,
 
     IoError(std::io::Error),
 }
@@ -128,13 +128,13 @@ pub(crate) use byzantine_fault;
 
 /// Result generated by the context packet receive function, with possible payloads.
 #[derive(Clone)]
-pub enum ReceiveOk<App: ApplicationLayer> {
+pub enum ReceiveOk<Crypto: CryptoLayer> {
     /// Packet superficially appeared valid but is not associated with a session yet.
     /// This can occur because the packet was only a fragment of a larger packet,
     /// or if it was a control packet that does not go through full Noise authentication.
     Unassociated,
     /// Packet was authentic and belongs to this specific session.
-    Session(Arc<Session<App>>, SessionEvent),
+    Session(Arc<Session<Crypto>>, SessionEvent),
 }
 /// Something that can occur to an associated session when a packet is received successfully,
 /// including receiving a payload of decrypted, authenticated data.
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 71cf4d0..5981e3c 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -2,19 +2,19 @@ use std::marker::PhantomData;
 
 use zeroize::Zeroizing;
 
-use crate::application::ApplicationLayer;
+use crate::application::CryptoLayer;
 use crate::crypto::*;
 use crate::proto::*;
 
-pub struct SymmetricState<App: ApplicationLayer> {
+pub struct SymmetricState<Crypto: CryptoLayer> {
     k: Zeroizing<[u8; AES_256_KEY_SIZE]>,
     ck: Zeroizing<[u8; HASHLEN]>,
     h: [u8; HASHLEN],
     /// If anyone knows a better way to get rid of the "parameter `App` is never used" error please
     /// let me know.
-    _app: PhantomData<fn() -> App::SessionData>,
+    _app: PhantomData<fn() -> Crypto::SessionData>,
 }
-impl<App: ApplicationLayer> Clone for SymmetricState<App> {
+impl<Crypto: CryptoLayer> Clone for SymmetricState<Crypto> {
     fn clone(&self) -> Self {
         Self {
             k: self.k.clone(),
@@ -25,7 +25,7 @@ impl<App: ApplicationLayer> Clone for SymmetricState<App> {
     }
 }
 
-impl<App: ApplicationLayer> SymmetricState<App> {
+impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
     /// HMAC-SHA512 key derivation based on KBKDF Counter Mode:
     /// https://csrc.nist.gov/publications/detail/sp/800-108/rev-1/final.
     /// Cryptographically this isn't meaningfully different from
@@ -40,7 +40,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     /// Corresponds to Noise `HKDF`.
     fn kbkdf(
         &self,
-        hmac: &mut App::Hmac,
+        hmac: &mut Crypto::Hmac,
         input_key_material: &[u8],
         label: &[u8; 4],
         num_outputs: u16,
@@ -86,7 +86,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         }
     }
     /// Corresponds to Noise `MixKey`.
-    pub fn mix_key(&mut self, hmac: &mut App::Hmac, input_key_material: &[u8]) {
+    pub fn mix_key(&mut self, hmac: &mut Crypto::Hmac, input_key_material: &[u8]) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
         let mut temp_k = Zeroizing::new([0u8; HASHLEN]);
 
@@ -104,7 +104,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
     /// Corresponds to Noise `MixKey`.
-    pub fn mix_key_no_init(&mut self, hmac: &mut App::Hmac, input_key_material: &[u8]) {
+    pub fn mix_key_no_init(&mut self, hmac: &mut Crypto::Hmac, input_key_material: &[u8]) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
 
         self.kbkdf(hmac, input_key_material, LABEL_KBKDF_CHAIN, 2, &mut next_ck, None, None);
@@ -112,13 +112,13 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         *self.ck = *next_ck;
     }
     /// Corresponds to Noise `MixHash`.
-    pub fn mix_hash(&mut self, hash: &mut App::Hash, data: &[u8]) {
+    pub fn mix_hash(&mut self, hash: &mut Crypto::Hash, data: &[u8]) {
         hash.update(&self.h);
         hash.update(data);
         hash.finish_and_reset(&mut self.h);
     }
     /// Corresponds to Noise `MixKeyAndHash`.
-    pub fn mix_key_and_hash(&mut self, hash: &mut App::Hash, hmac: &mut App::Hmac, input_key_material: &[u8]) {
+    pub fn mix_key_and_hash(&mut self, hash: &mut Crypto::Hash, hmac: &mut Crypto::Hmac, input_key_material: &[u8]) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
         let mut temp_h = [0u8; HASHLEN];
         let mut temp_k = Zeroizing::new([0u8; HASHLEN]);
@@ -138,7 +138,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
     /// Corresponds to Noise `MixKeyAndHash`.
-    pub fn mix_key_and_hash_no_init(&mut self, hash: &mut App::Hash, hmac: &mut App::Hmac, input_key_material: &[u8]) {
+    pub fn mix_key_and_hash_no_init(&mut self, hash: &mut Crypto::Hash, hmac: &mut Crypto::Hmac, input_key_material: &[u8]) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
         let mut temp_h = [0u8; HASHLEN];
 
@@ -159,11 +159,11 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     #[must_use]
     pub fn encrypt_and_hash_in_place(
         &mut self,
-        hash: &mut App::Hash,
+        hash: &mut Crypto::Hash,
         iv: [u8; AES_GCM_NONCE_SIZE],
         data: &mut [u8],
     ) -> [u8; AES_GCM_TAG_SIZE] {
-        let tag = App::Aead::encrypt_in_place(&self.k, &iv, &self.h, data);
+        let tag = Crypto::Aead::encrypt_in_place(&self.k, &iv, &self.h, data);
         hash.update(&self.h);
         hash.update(data);
         hash.update(&tag);
@@ -174,7 +174,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     #[must_use]
     pub fn decrypt_and_hash_in_place(
         &mut self,
-        hash: &mut App::Hash,
+        hash: &mut Crypto::Hash,
         iv: [u8; AES_GCM_NONCE_SIZE],
         data: &mut [u8],
         tag: [u8; AES_GCM_TAG_SIZE],
@@ -182,19 +182,19 @@ impl<App: ApplicationLayer> SymmetricState<App> {
         hash.update(&self.h);
         hash.update(data);
         hash.update(&tag);
-        let is_auth = App::Aead::decrypt_in_place(&self.k, &iv, &self.h, data, tag.as_ref().try_into().unwrap());
+        let is_auth = Crypto::Aead::decrypt_in_place(&self.k, &iv, &self.h, data, tag.as_ref().try_into().unwrap());
         hash.finish_and_reset(&mut self.h);
         is_auth
     }
     /// Corresponds to Noise `Split`.
-    pub fn split(self, hmac: &mut App::Hmac, key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
+    pub fn split(self, hmac: &mut Crypto::Hmac, key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
         self.kbkdf(hmac, &[], LABEL_KBKDF_CHAIN, 2, key1, Some(key2), None);
     }
     /// Get an additional symmetric key (ASK) that is a collision resistant hash of the transcript,
     /// is forward secrect and is cryptographically independent from all other produced keys.
     /// Based on Noise's unstable ASK mechanism, using KBKDF instead of HKDF.
     /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
-    pub fn get_ask(&self, hmac: &mut App::Hmac, label: &[u8; 4], key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
+    pub fn get_ask(&self, hmac: &mut Crypto::Hmac, label: &[u8; 4], key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
         self.kbkdf(hmac, &self.h, label, 2, key1, Some(key2), None);
     }
     /// Used for internally debugging a key exchange.
diff --git a/src/zeta.rs b/src/zeta.rs
index f824eb0..24c3dbf 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -24,60 +24,60 @@ use crate::zssp::{log, ContextInner, SessionQueue};
 use crate::LogEvent::*;
 
 /// Corresponds to the Zeta State Machine found in Section 4.1.
-pub struct Session<App: ApplicationLayer> {
-    ctx: Weak<ContextInner<App>>,
+pub struct Session<Crypto: CryptoLayer> {
+    ctx: Weak<ContextInner<Crypto>>,
     /// An arbitrary application defined object associated with each session.
-    pub session_data: App::SessionData,
+    pub session_data: Crypto::SessionData,
     /// Is true if the local peer acted as Bob, the responder in the initial key exchange.
     pub was_bob: bool,
     queue_idx: BinaryHeapIndex,
 
-    pub(crate) s_remote: App::PublicKey,
+    pub(crate) s_remote: Crypto::PublicKey,
     send_counter: AtomicU64,
     session_has_expired: AtomicBool,
 
     pub window: Window<COUNTER_WINDOW_MAX_OOO, COUNTER_WINDOW_MAX_SKIP_AHEAD>,
-    pub(crate) defrag: [Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
+    pub(crate) defrag: [Mutex<Fragged<Crypto::IncomingPacketBuffer, MAX_FRAGMENTS>>; SESSION_MAX_FRAGMENTS_OOO],
 
     /// `session_queue -> state_machine_lock -> state -> session_map`
     state_machine_lock: Mutex<()>,
     /// `session_queue -> state_machine_lock -> state -> session_map`
-    pub(crate) state: RwLock<MutableState<App>>,
+    pub(crate) state: RwLock<MutableState<Crypto>>,
 
     /// Pre-computed rekeying value.
     noise_kk_ss: Zeroizing<[u8; P384_ECDH_SHARED_SECRET_SIZE]>,
 }
-pub(crate) struct MutableState<App: ApplicationLayer> {
+pub(crate) struct MutableState<Crypto: CryptoLayer> {
     ratchet_state1: RatchetState,
     ratchet_state2: Option<RatchetState>,
 
-    pub(crate) hk_send: App::PrpEnc,
-    pub(crate) hk_recv: App::PrpDec,
+    pub(crate) hk_send: Crypto::PrpEnc,
+    pub(crate) hk_recv: Crypto::PrpDec,
     key_creation_counter: u64,
     key_index: bool,
-    keys: [DuplexKey<App>; 2],
+    keys: [DuplexKey<Crypto>; 2],
 
     resend_timer: AtomicI64,
     timeout_timer: i64,
-    pub(crate) beta: ZetaAutomata<App>,
+    pub(crate) beta: ZetaAutomata<Crypto>,
 }
 
 /// Corresponds to State B_2 of the Zeta State Machine found in Section 4.1 - Definition 3.
-pub(crate) struct StateB2<App: ApplicationLayer> {
+pub(crate) struct StateB2<Crypto: CryptoLayer> {
     ratchet_state: RatchetState,
     kid_send: NonZeroU32,
     pub kid_recv: NonZeroU32,
     pub hk_send: Zeroizing<[u8; AES_256_KEY_SIZE]>,
     pub hk_recv: Zeroizing<[u8; AES_256_KEY_SIZE]>,
-    e_secret: App::KeyPair,
-    noise: SymmetricState<App>,
-    pub defrag: Mutex<Fragged<App::IncomingPacketBuffer, MAX_FRAGMENTS>>,
+    e_secret: Crypto::KeyPair,
+    noise: SymmetricState<Crypto>,
+    pub defrag: Mutex<Fragged<Crypto::IncomingPacketBuffer, MAX_FRAGMENTS>>,
 }
 
-pub(crate) struct DuplexKey<App: ApplicationLayer> {
+pub(crate) struct DuplexKey<Crypto: CryptoLayer> {
     send: Keys,
     recv: Keys,
-    nk: Option<App::AeadPool>,
+    nk: Option<Crypto::AeadPool>,
 }
 
 #[derive(Default)]
@@ -88,10 +88,10 @@ pub(crate) struct Keys {
 
 /// Corresponds to State A_1 of the Zeta State Machine found in Section 4.1.
 #[derive(Clone)]
-pub(crate) struct StateA1<App: ApplicationLayer> {
-    noise: SymmetricState<App>,
-    e_secret: App::KeyPair,
-    e1_secret: App::Kem,
+pub(crate) struct StateA1<Crypto: CryptoLayer> {
+    noise: SymmetricState<Crypto>,
+    e_secret: Crypto::KeyPair,
+    e1_secret: Crypto::Kem,
     identity: ArrayVec<u8, IDENTITY_MAX_SIZE>,
     x1: ArrayVec<u8, HEADERED_HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE>,
 }
@@ -102,15 +102,15 @@ pub(crate) struct StateA3 {
 }
 
 /// Corresponds to the ZKE Automata found in Section 4.1 - Definition 2.
-pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
+pub(crate) enum ZetaAutomata<Crypto: CryptoLayer> {
     Null,
-    A1(Box<StateA1<App>>),
+    A1(Box<StateA1<Crypto>>),
     A3(Box<StateA3>),
     S1,
     S2,
     R1 {
-        noise: SymmetricState<App>,
-        e_secret: App::KeyPair,
+        noise: SymmetricState<Crypto>,
+        e_secret: Crypto::KeyPair,
         k1: ArrayVec<u8, HEADERED_REKEY_SIZE>,
     },
     R2 {
@@ -118,14 +118,14 @@ pub(crate) enum ZetaAutomata<App: ApplicationLayer> {
     },
 }
 
-impl<App: ApplicationLayer> Default for DuplexKey<App> {
+impl<Crypto: CryptoLayer> Default for DuplexKey<Crypto> {
     fn default() -> Self {
         Self { send: Default::default(), recv: Default::default(), nk: None }
     }
 }
-impl<App: ApplicationLayer> DuplexKey<App> {
+impl<Crypto: CryptoLayer> DuplexKey<Crypto> {
     fn replace_nk(&mut self, nk_send: &[u8; HASHLEN], nk_recv: &[u8; HASHLEN]) {
-        self.nk = Some(App::AeadPool::new(
+        self.nk = Some(Crypto::AeadPool::new(
             (&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap(),
             (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap(),
         ))
@@ -141,24 +141,24 @@ impl Keys {
     }
 }
 
-impl<App: ApplicationLayer> MutableState<App> {
-    fn key_ref(&self, is_next: bool) -> &DuplexKey<App> {
+impl<Crypto: CryptoLayer> MutableState<Crypto> {
+    fn key_ref(&self, is_next: bool) -> &DuplexKey<Crypto> {
         &self.keys[(self.key_index ^ is_next) as usize]
     }
-    fn key_mut(&mut self, is_next: bool) -> &mut DuplexKey<App> {
+    fn key_mut(&mut self, is_next: bool) -> &mut DuplexKey<Crypto> {
         &mut self.keys[(self.key_index ^ is_next) as usize]
     }
 }
 
-impl<App: ApplicationLayer> SymmetricState<App> {
+impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
     fn write_e_no_init<const CAP: usize>(
         &mut self,
-        hash: &mut App::Hash,
-        hmac: &mut App::Hmac,
-        rng: &Mutex<App::Rng>,
+        hash: &mut Crypto::Hash,
+        hmac: &mut Crypto::Hmac,
+        rng: &Mutex<Crypto::Rng>,
         packet: &mut ArrayVec<u8, CAP>,
-    ) -> App::KeyPair {
-        let e_secret = App::KeyPair::generate(rng.lock().unwrap().deref_mut());
+    ) -> Crypto::KeyPair {
+        let e_secret = Crypto::KeyPair::generate(rng.lock().unwrap().deref_mut());
         let pub_key = e_secret.public_key_bytes();
         packet.extend(pub_key);
         self.mix_hash(hash, &pub_key);
@@ -167,19 +167,19 @@ impl<App: ApplicationLayer> SymmetricState<App> {
     }
     fn read_e_no_init(
         &mut self,
-        hash: &mut App::Hash,
-        hmac: &mut App::Hmac,
+        hash: &mut Crypto::Hash,
+        hmac: &mut Crypto::Hmac,
         i: &mut usize,
         packet: &[u8],
-    ) -> Option<App::PublicKey> {
+    ) -> Option<Crypto::PublicKey> {
         let j = *i + P384_PUBLIC_KEY_SIZE;
         let pub_key = &packet[*i..j];
         self.mix_hash(hash, pub_key);
         self.mix_key_no_init(hmac, pub_key);
         *i = j;
-        App::PublicKey::from_bytes((pub_key).try_into().unwrap())
+        Crypto::PublicKey::from_bytes((pub_key).try_into().unwrap())
     }
-    fn mix_dh(&mut self, hmac: &mut App::Hmac, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
+    fn mix_dh(&mut self, hmac: &mut Crypto::Hmac, secret: &Crypto::KeyPair, remote: &Crypto::PublicKey) -> Option<()> {
         let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
         if secret.agree(&remote, &mut ecdh_secret) {
             self.mix_key(hmac, ecdh_secret.as_ref());
@@ -188,7 +188,7 @@ impl<App: ApplicationLayer> SymmetricState<App> {
             None
         }
     }
-    fn mix_dh_no_init(&mut self, hmac: &mut App::Hmac, secret: &App::KeyPair, remote: &App::PublicKey) -> Option<()> {
+    fn mix_dh_no_init(&mut self, hmac: &mut Crypto::Hmac, secret: &Crypto::KeyPair, remote: &Crypto::PublicKey) -> Option<()> {
         let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
         if secret.agree(&remote, &mut ecdh_secret) {
             self.mix_key_no_init(hmac, ecdh_secret.as_ref());
@@ -225,9 +225,9 @@ fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_NONCE_SIZE]
     packet[..KID_SIZE].copy_from_slice(&kid_send.to_ne_bytes());
     packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
 }
-fn create_ratchet_state<App: ApplicationLayer>(
-    hmac: &mut App::Hmac,
-    noise: &SymmetricState<App>,
+fn create_ratchet_state<Crypto: CryptoLayer>(
+    hmac: &mut Crypto::Hmac,
+    noise: &SymmetricState<Crypto>,
     pre_chain_len: u64,
 ) -> RatchetState {
     let mut rk = Zeroizing::new([0u8; HASHLEN]);
@@ -239,7 +239,7 @@ fn create_ratchet_state<App: ApplicationLayer>(
         pre_chain_len + 1,
     )
 }
-fn get_counter<App: ApplicationLayer>(session: &Session<App>, state: &MutableState<App>) -> Option<(u64, bool)> {
+fn get_counter<Crypto: CryptoLayer>(session: &Session<Crypto>, state: &MutableState<Crypto>) -> Option<(u64, bool)> {
     if session.session_has_expired.load(Ordering::Relaxed) {
         None
     } else {
@@ -251,7 +251,7 @@ fn get_counter<App: ApplicationLayer>(session: &Session<App>, state: &MutableSta
             session.session_has_expired.store(true, Ordering::SeqCst);
             return None;
         }
-        Some((c, c > state.key_creation_counter + App::SETTINGS.rekey_after_key_uses))
+        Some((c, c > state.key_creation_counter + Crypto::SETTINGS.rekey_after_key_uses))
     }
 }
 
@@ -265,10 +265,10 @@ fn gen_kid<T>(session_map: &HashMap<NonZeroU32, T>, rng: &mut impl RngCore) -> N
         }
     }
 }
-fn remap<App: ApplicationLayer>(
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
-    state: &MutableState<App>,
+fn remap<Crypto: CryptoLayer>(
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Arc<Session<Crypto>>,
+    state: &MutableState<Crypto>,
 ) -> NonZeroU32 {
     let mut session_map = ctx.session_map.write().unwrap();
     let weak = if let Some(Some(weak)) = state.key_ref(true).recv.kid.as_ref().map(|kid| session_map.remove(kid)) {
@@ -281,20 +281,20 @@ fn remap<App: ApplicationLayer>(
     new_kid_recv
 }
 
-fn create_a1_state<App: ApplicationLayer>(
-    hash: &mut App::Hash,
-    hmac: &mut App::Hmac,
-    rng: &Mutex<App::Rng>,
-    s_remote: &App::PublicKey,
+fn create_a1_state<Crypto: CryptoLayer>(
+    hash: &mut Crypto::Hash,
+    hmac: &mut Crypto::Hmac,
+    rng: &Mutex<Crypto::Rng>,
+    s_remote: &Crypto::PublicKey,
     kid_recv: NonZeroU32,
     ratchet_state1: &RatchetState,
     ratchet_state2: Option<&RatchetState>,
     identity: &[u8],
-) -> Option<Box<StateA1<App>>> {
+) -> Option<Box<StateA1<Crypto>>> {
     //    <- s
     //    ...
     //    -> e, es, e1
-    let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_XK);
+    let mut noise = SymmetricState::<Crypto>::initialize(PROTOCOL_NAME_NOISE_XK);
     let mut x1 = ArrayVec::<u8, HEADERED_HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE>::new();
     x1.extend([0u8; HEADER_SIZE]);
     // Noise process prologue.
@@ -308,7 +308,7 @@ fn create_a1_state<App: ApplicationLayer>(
     noise.mix_dh(hmac, &e_secret, s_remote)?;
     // Process message pattern 1 e1 token.
     let i = x1.len();
-    let (e1_secret, e1_public) = App::Kem::generate(rng.lock().unwrap().deref_mut());
+    let (e1_secret, e1_public) = Crypto::Kem::generate(rng.lock().unwrap().deref_mut());
     x1.extend(e1_public);
     let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), &mut x1[i..]);
     x1.extend(tag);
@@ -339,25 +339,25 @@ fn create_a1_state<App: ApplicationLayer>(
     }))
 }
 /// Corresponds to Transition Algorithm 1 found in Section 4.3.
-pub(crate) fn trans_to_a1<App: ApplicationLayer>(
-    app: App,
-    ctx: &Arc<ContextInner<App>>,
-    s_remote: App::PublicKey,
-    session_data: App::SessionData,
+pub(crate) fn trans_to_a1<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    mut app: App,
+    ctx: &Arc<ContextInner<Crypto>>,
+    s_remote: Crypto::PublicKey,
+    session_data: Crypto::SessionData,
     identity: &[u8],
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
+) -> Result<Arc<Session<Crypto>>, OpenError> {
     let RatchetStates { state1, state2 } = app
         .restore_by_identity(&s_remote, &session_data)
-        .map_err(|e| OpenError::RatchetIoError(e))?
+        .map_err(|_| OpenError::RatchetStorageError)?
         .unwrap_or_default();
 
     let mut session_queue = ctx.session_queue.lock().unwrap();
     let mut session_map = ctx.session_map.write().unwrap();
     let kid_recv = gen_kid(session_map.deref(), ctx.rng.lock().unwrap().deref_mut());
 
-    let hash = &mut App::Hash::new();
-    let hmac = &mut App::Hmac::new();
+    let hash = &mut Crypto::Hash::new();
+    let hmac = &mut Crypto::Hmac::new();
     let a1 = create_a1_state(
         hash,
         hmac,
@@ -383,7 +383,7 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
 
     let current_time = app.time();
     let queue_idx = session_queue.reserve_index();
-    let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+    let resend_timer = current_time + Crypto::SETTINGS.resend_time as i64;
     let session = Arc::new(Session {
         ctx: Arc::downgrade(ctx),
         session_data,
@@ -397,13 +397,13 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
         state: RwLock::new(MutableState {
             ratchet_state1: state1.clone(),
             ratchet_state2: state2.clone(),
-            hk_send: App::PrpEnc::new((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap()),
-            hk_recv: App::PrpDec::new((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()),
+            hk_send: Crypto::PrpEnc::new((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap()),
+            hk_recv: Crypto::PrpDec::new((&hk_recv[..AES_256_KEY_SIZE]).try_into().unwrap()),
             key_creation_counter: 0,
             key_index: true,
             keys: [DuplexKey::default(), DuplexKey::default()],
             resend_timer: AtomicI64::new(resend_timer),
-            timeout_timer: current_time + App::SETTINGS.initial_offer_timeout as i64,
+            timeout_timer: current_time + Crypto::SETTINGS.initial_offer_timeout as i64,
             beta: ZetaAutomata::A1(a1),
         }),
         noise_kk_ss: noise_kk_ss.clone(),
@@ -422,9 +422,9 @@ pub(crate) fn trans_to_a1<App: ApplicationLayer>(
     Ok(session)
 }
 /// Corresponds to Algorithm 13 found in Section 5.
-pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
-    ctx: &Arc<ContextInner<App>>,
-    session: &Session<App>,
+pub(crate) fn respond_to_challenge<Crypto: CryptoLayer>(
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Session<Crypto>,
     challenge: &[u8; CHALLENGE_SIZE],
 ) {
     let mut state = session.state.write().unwrap();
@@ -432,21 +432,21 @@ pub(crate) fn respond_to_challenge<App: ApplicationLayer>(
         let response_start = a1.x1.len() - CHALLENGE_SIZE;
         respond_to_challenge_in_place(
             ctx.rng.lock().unwrap().deref_mut(),
-            &mut App::Hash::new(),
+            &mut Crypto::Hash::new(),
             challenge,
             (&mut a1.x1[response_start..]).try_into().unwrap(),
         );
     }
 }
 /// Corresponds to Transition Algorithm 2 found in Section 4.3.
-pub(crate) fn received_x1_trans<App: ApplicationLayer>(
-    app: &App,
-    ctx: &ContextInner<App>,
-    hash: &mut App::Hash,
+pub(crate) fn received_x1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    app: &mut App,
+    ctx: &ContextInner<Crypto>,
+    hash: &mut Crypto::Hash,
     n: &[u8; AES_GCM_NONCE_SIZE],
     x1: &mut [u8],
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) -> Result<(), ReceiveError<App::StorageError>> {
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
+) -> Result<(), ReceiveError> {
     use FaultType::*;
     //    <- s
     //    ...
@@ -459,8 +459,8 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     if &n[AES_GCM_NONCE_SIZE - 8..] != &x1[x1.len() - 8..] {
         return Err(byzantine_fault!(FailedAuth, true));
     }
-    let hmac = &mut App::Hmac::new();
-    let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_XK);
+    let hmac = &mut Crypto::Hmac::new();
+    let mut noise = SymmetricState::<Crypto>::initialize(PROTOCOL_NAME_NOISE_XK);
     let mut i = 0;
     // Noise process prologue.
     let j = i + KID_SIZE;
@@ -503,7 +503,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
                 ratchet_state = Some(rs);
                 break;
             }
-            Err(e) => return Err(ReceiveError::StorageError(e)),
+            Err(_) => return Err(ReceiveError::RatchetStorageError),
         }
         i += RATCHET_SIZE;
     }
@@ -532,7 +532,7 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
     {
         let i = x2.len();
         let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
-        let ekem1 = App::Kem::encapsulate(
+        let ekem1 = Crypto::Kem::encapsulate(
             ctx.rng.lock().unwrap().deref_mut(),
             (&x1[e1_start..e1_end]).try_into().unwrap(),
             &mut ekem1_secret,
@@ -582,20 +582,20 @@ pub(crate) fn received_x1_trans<App: ApplicationLayer>(
 
     send(
         &mut x2,
-        Some(&App::PrpEnc::new(&hk_send[..AES_256_KEY_SIZE].try_into().unwrap())),
+        Some(&Crypto::PrpEnc::new(&hk_send[..AES_256_KEY_SIZE].try_into().unwrap())),
     );
     Ok(())
 }
 /// Corresponds to Transition Algorithm 3 found in Section 4.3.
-pub(crate) fn received_x2_trans<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
+pub(crate) fn received_x2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    app: &mut App,
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Arc<Session<Crypto>>,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_NONCE_SIZE],
     x2: &mut [u8],
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) -> Result<bool, ReceiveError<App::StorageError>> {
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
+) -> Result<bool, ReceiveError> {
     use FaultType::*;
     //    <- e, ee, ekem1, psk
     //    -> s, se
@@ -605,8 +605,8 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
 
     let kex_lock = session.state_machine_lock.lock().unwrap();
     let state = session.state.read().unwrap();
-    let hash = &mut App::Hash::new();
-    let hmac = &mut App::Hmac::new();
+    let hash = &mut Crypto::Hash::new();
+    let hmac = &mut Crypto::Hmac::new();
 
     if Some(kid) != state.key_ref(true).recv.kid {
         return Err(byzantine_fault!(UnknownLocalKeyId, true));
@@ -660,7 +660,7 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         let payload: [u8; KID_SIZE] = x2[i..j].try_into().unwrap();
         let tag = x2[j..k].try_into().unwrap();
         // Check for which ratchet key Bob wants to use.
-        let mut test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState<App>)> {
+        let mut test_ratchet_key = |ratchet_key| -> Option<(NonZeroU32, SymmetricState<Crypto>)> {
             let mut noise = noise.clone();
             let mut payload = payload.clone();
             // Process message pattern 2 psk token.
@@ -729,8 +729,8 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
                 deleted_state2: None,
             },
         );
-        if let Err(e) = result {
-            return Err(ReceiveError::StorageError(e));
+        if let Err(()) = result {
+            return Err(ReceiveError::RatchetStorageError);
         }
 
         let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
@@ -754,9 +754,9 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
             state.ratchet_state1 = new_ratchet_state.clone();
             let current_time = app.time();
             state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
-            let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+            let resend_timer = current_time + Crypto::SETTINGS.resend_time as i64;
             state.resend_timer = AtomicI64::new(resend_timer);
-            state.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
+            state.timeout_timer = current_time + Crypto::SETTINGS.initial_offer_timeout as i64;
             let a1 = if let ZetaAutomata::A1(a1) = &state.beta {
                 a1
             } else {
@@ -779,24 +779,25 @@ pub(crate) fn received_x2_trans<App: ApplicationLayer>(
         Err(ReceiveError::ByzantineFault { .. }) => {
             let kex_lock = session.state_machine_lock.lock().unwrap();
             let state = session.state.read().unwrap();
-            timeout_trans(app, ctx, session, kex_lock, state, app.time(), send);
+            let current_time = app.time();
+            timeout_trans(app, ctx, session, kex_lock, state, current_time, send);
         }
         Ok(ref mut packet) => send(packet, Some(&session.state.read().unwrap().hk_send)),
         _ => {}
     }
     result.map(|_| should_warn_missing_ratchet)
 }
-fn send_control<App: ApplicationLayer, const CAP: usize>(
-    session: &Arc<Session<App>>,
-    state: &MutableState<App>,
+fn send_control<Crypto: CryptoLayer, const CAP: usize>(
+    session: &Arc<Session<Crypto>>,
+    state: &MutableState<Crypto>,
     packet_type: u8,
     mut payload: ArrayVec<u8, CAP>,
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
 ) -> bool {
     if let Some((c, _)) = get_counter(session, &state) {
         if let (Some(kek), Some(kid)) = (state.key_ref(false).send.kek.as_ref(), state.key_ref(false).send.kid) {
             let nonce = to_nonce(packet_type, c);
-            let tag = App::Aead::encrypt_in_place(kek, &nonce, &[], &mut payload[HEADER_SIZE..]);
+            let tag = Crypto::Aead::encrypt_in_place(kek, &nonce, &[], &mut payload[HEADER_SIZE..]);
             payload.extend(tag);
             set_header(&mut payload, kid.get(), &nonce);
             send(&mut payload, Some(&state.hk_send));
@@ -809,14 +810,14 @@ fn send_control<App: ApplicationLayer, const CAP: usize>(
     }
 }
 /// Corresponds to Transition Algorithm 4 found in Section 4.3.
-pub(crate) fn received_x3_trans<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
-    zeta: Arc<StateB2<App>>,
+pub(crate) fn received_x3_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    app: &mut App,
+    ctx: &Arc<ContextInner<Crypto>>,
+    zeta: Arc<StateB2<Crypto>>,
     kid: NonZeroU32,
     x3: &mut [u8],
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) -> Result<(Arc<Session<App>>, bool), ReceiveError<App::StorageError>> {
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
+) -> Result<(Arc<Session<Crypto>>, bool), ReceiveError> {
     use FaultType::*;
     //    -> s, se
     if x3.len() < HANDSHAKE_COMPLETION_MIN_SIZE {
@@ -825,8 +826,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
     if kid != zeta.kid_recv {
         return Err(byzantine_fault!(UnknownLocalKeyId, true));
     }
-    let hash = &mut App::Hash::new();
-    let hmac = &mut App::Hmac::new();
+    let hash = &mut Crypto::Hash::new();
+    let hmac = &mut Crypto::Hmac::new();
 
     let mut noise = zeta.noise.clone();
     let mut i = 0;
@@ -838,7 +839,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let s_remote =
-        App::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
+        Crypto::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
     i = k;
     // Process message pattern 3 se token.
     noise
@@ -870,7 +871,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
         let mut d = ArrayVec::<u8, HEADERED_SESSION_REJECTED_SIZE>::new();
         d.extend([0u8; HEADER_SIZE]);
         let nonce = to_nonce(PACKET_TYPE_SESSION_REJECTED, c);
-        d.extend(App::Aead::encrypt_in_place(
+        d.extend(Crypto::Aead::encrypt_in_place(
             (&kek_send[..AES_256_KEY_SIZE]).try_into().unwrap(),
             &nonce,
             &[],
@@ -891,7 +892,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                         should_warn_missing_ratchet = true;
                     } else {
                         if !responder_silently_rejects {
-                            send(&mut create_reject(), Some(&App::PrpEnc::new(&zeta.hk_send)))
+                            send(&mut create_reject(), Some(&Crypto::PrpEnc::new(&zeta.hk_send)))
                         }
                         return Err(byzantine_fault!(FailedAuth, true));
                     }
@@ -919,8 +920,8 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                         deleted_state2: state2.as_ref(),
                     },
                 );
-                if let Err(e) = result {
-                    return Err(ReceiveError::StorageError(e));
+                if let Err(()) = result {
+                    return Err(ReceiveError::RatchetStorageError);
                 }
 
                 let session = {
@@ -935,7 +936,7 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                     let mut session_queue = ctx.session_queue.lock().unwrap();
                     let queue_idx = session_queue.reserve_index();
                     let current_time = app.time();
-                    let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                    let resend_timer = current_time + Crypto::SETTINGS.resend_time as i64;
                     let session = Arc::new(Session {
                         ctx: Arc::downgrade(ctx),
                         session_data,
@@ -947,13 +948,13 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
                         state: RwLock::new(MutableState {
                             ratchet_state1: new_ratchet_state.clone(),
                             ratchet_state2: None,
-                            hk_send: App::PrpEnc::new(&zeta.hk_send),
-                            hk_recv: App::PrpDec::new(&zeta.hk_recv),
+                            hk_send: Crypto::PrpEnc::new(&zeta.hk_send),
+                            hk_recv: Crypto::PrpDec::new(&zeta.hk_recv),
                             key_creation_counter: c + 1,
                             key_index: false,
                             keys: [DuplexKey::default(), DuplexKey::default()],
                             resend_timer: AtomicI64::new(resend_timer),
-                            timeout_timer: current_time + App::SETTINGS.rekey_timeout as i64,
+                            timeout_timer: current_time + Crypto::SETTINGS.rekey_timeout as i64,
                             beta: ZetaAutomata::S1,
                         }),
                         window: Window::new(),
@@ -983,25 +984,25 @@ pub(crate) fn received_x3_trans<App: ApplicationLayer>(
 
                 Ok((session, should_warn_missing_ratchet))
             }
-            Err(e) => Err(ReceiveError::StorageError(e)),
+            Err(()) => Err(ReceiveError::RatchetStorageError),
         }
     } else {
         if !responder_silently_rejects {
-            send(&mut create_reject(), Some(&App::PrpEnc::new(&zeta.hk_send)))
+            send(&mut create_reject(), Some(&Crypto::PrpEnc::new(&zeta.hk_send)))
         }
         Err(ReceiveError::Rejected)
     }
 }
 /// Corresponds to Transition Algorithm 5 found in Section 4.3.
-pub(crate) fn received_c1_trans<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
+pub(crate) fn received_c1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    app: &mut App,
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Arc<Session<Crypto>>,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_NONCE_SIZE],
     c1: &[u8],
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) -> Result<bool, ReceiveError<App::StorageError>> {
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
+) -> Result<bool, ReceiveError> {
     use FaultType::*;
 
     if c1.len() != KEY_CONFIRMATION_SIZE {
@@ -1024,7 +1025,7 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
     let specified_key = state.key_ref(is_other).recv.kek.as_ref();
     let specified_key = specified_key.ok_or(byzantine_fault!(OutOfSequence, true))?;
     let tag = c1[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(specified_key, n, &[], &mut [], tag) {
+    if !Crypto::Aead::decrypt_in_place(specified_key, n, &[], &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
@@ -1047,8 +1048,8 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
                         deleted_state2: None,
                     },
                 );
-                if let Err(e) = result {
-                    return Err(ReceiveError::StorageError(e));
+                if let Err(()) = result {
+                    return Err(ReceiveError::RatchetStorageError);
                 }
             }
             drop(state);
@@ -1057,9 +1058,9 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
                 state.ratchet_state2 = None;
                 state.key_index ^= true;
                 state.timeout_timer = app.time()
-                    + App::SETTINGS
+                    + Crypto::SETTINGS
                         .rekey_after_time
-                        .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter)
+                        .saturating_sub(ctx.rng.lock().unwrap().next_u64() % Crypto::SETTINGS.rekey_time_max_jitter)
                         as i64;
                 state.resend_timer = AtomicI64::new(i64::MAX);
                 state.beta = ZetaAutomata::S2;
@@ -1084,14 +1085,14 @@ pub(crate) fn received_c1_trans<App: ApplicationLayer>(
 }
 /// Corresponds to the trivial Transition Algorithm described for processing C_2 packets found in
 /// Section 4.3.
-pub(crate) fn received_c2_trans<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
+pub(crate) fn received_c2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    app: &mut App,
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Arc<Session<Crypto>>,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_NONCE_SIZE],
     c2: &[u8],
-) -> Result<(), ReceiveError<App::StorageError>> {
+) -> Result<(), ReceiveError> {
     use FaultType::*;
 
     if c2.len() != ACKNOWLEDGEMENT_SIZE {
@@ -1111,7 +1112,7 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     }
 
     let tag = c2[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut [], tag) {
+    if !Crypto::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
@@ -1122,9 +1123,9 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
     let timeout_timer = {
         let mut state = session.state.write().unwrap();
         state.timeout_timer = app.time()
-            + App::SETTINGS
+            + Crypto::SETTINGS
                 .rekey_after_time
-                .saturating_sub(ctx.rng.lock().unwrap().next_u64() % App::SETTINGS.rekey_time_max_jitter)
+                .saturating_sub(ctx.rng.lock().unwrap().next_u64() % Crypto::SETTINGS.rekey_time_max_jitter)
                 as i64;
         state.resend_timer = AtomicI64::new(i64::MAX);
         state.beta = ZetaAutomata::S2;
@@ -1139,12 +1140,12 @@ pub(crate) fn received_c2_trans<App: ApplicationLayer>(
 }
 /// Corresponds to the trivial Transition Algorithm described for processing D packets found in
 /// Section 4.3.
-pub(crate) fn received_d_trans<App: ApplicationLayer>(
-    session: &Arc<Session<App>>,
+pub(crate) fn received_d_trans<Crypto: CryptoLayer>(
+    session: &Arc<Session<Crypto>>,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_NONCE_SIZE],
     d: &[u8],
-) -> Result<(), ReceiveError<App::StorageError>> {
+) -> Result<(), ReceiveError> {
     use FaultType::*;
 
     if d.len() != SESSION_REJECTED_SIZE {
@@ -1159,7 +1160,7 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     }
 
     let tag = d[..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(state.key_ref(true).recv.kek.as_ref().unwrap(), n, &[], &mut [], tag) {
+    if !Crypto::Aead::decrypt_in_place(state.key_ref(true).recv.kek.as_ref().unwrap(), n, &[], &mut [], tag) {
         return Err(byzantine_fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
@@ -1173,14 +1174,14 @@ pub(crate) fn received_d_trans<App: ApplicationLayer>(
     Ok(())
 }
 // Corresponds to the timeout timer Transition Algorithm described in Section 4.1 - Definition 3.
-fn timeout_trans<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
+fn timeout_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    app: &mut App,
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Arc<Session<Crypto>>,
     kex_lock: MutexGuard<'_, ()>,
-    state: RwLockReadGuard<'_, MutableState<App>>,
+    state: RwLockReadGuard<'_, MutableState<Crypto>>,
     current_time: i64,
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
 ) -> Option<i64> {
     match &state.beta {
         ZetaAutomata::Null => None,
@@ -1197,8 +1198,8 @@ fn timeout_trans<App: ApplicationLayer>(
             }
             let new_kid_recv = remap(ctx, session, &state);
 
-            let hash = &mut App::Hash::new();
-            let hmac = &mut App::Hmac::new();
+            let hash = &mut Crypto::Hash::new();
+            let hmac = &mut Crypto::Hmac::new();
             if let Some(a1) = create_a1_state(
                 hash,
                 hmac,
@@ -1221,9 +1222,9 @@ fn timeout_trans<App: ApplicationLayer>(
                     state.hk_send.reset((&hk_send[..AES_256_KEY_SIZE]).try_into().unwrap());
                     *state.key_mut(true) = DuplexKey::default();
                     state.key_mut(true).recv.kid = Some(new_kid_recv);
-                    let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                    let resend_timer = current_time + Crypto::SETTINGS.resend_time as i64;
                     state.resend_timer = AtomicI64::new(resend_timer);
-                    state.timeout_timer = current_time + App::SETTINGS.initial_offer_timeout as i64;
+                    state.timeout_timer = current_time + Crypto::SETTINGS.initial_offer_timeout as i64;
                     state.beta = ZetaAutomata::A1(a1);
                     resend_timer
                 };
@@ -1244,8 +1245,8 @@ fn timeout_trans<App: ApplicationLayer>(
             //    ...
             //    -> psk, e, es, ss
             let mut noise = SymmetricState::initialize(PROTOCOL_NAME_NOISE_KK);
-            let hash = &mut App::Hash::new();
-            let hmac = &mut App::Hmac::new();
+            let hash = &mut Crypto::Hash::new();
+            let hmac = &mut Crypto::Hmac::new();
             let mut k1 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
             k1.extend([0u8; HEADER_SIZE]);
             // Noise process prologue.
@@ -1271,8 +1272,8 @@ fn timeout_trans<App: ApplicationLayer>(
             let resend_timer = {
                 let mut state = session.state.write().unwrap();
                 state.key_mut(true).recv.kid = Some(new_kid_recv);
-                state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
-                let resend_timer = current_time + App::SETTINGS.resend_time as i64;
+                state.timeout_timer = current_time + Crypto::SETTINGS.rekey_timeout as i64;
+                let resend_timer = current_time + Crypto::SETTINGS.resend_time as i64;
                 state.resend_timer = AtomicI64::new(resend_timer);
                 state.beta = ZetaAutomata::R1 { noise, e_secret, k1: k1.clone() };
                 resend_timer
@@ -1298,12 +1299,12 @@ fn timeout_trans<App: ApplicationLayer>(
     }
 }
 /// Corresponds to the timer rules of the Zeta State Machine found in Section 4.1 - Definition 3.
-pub(crate) fn process_timers<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
+pub(crate) fn process_timers<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    app: &mut App,
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Arc<Session<Crypto>>,
     current_time: i64,
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
 ) -> Option<i64> {
     let kex_lock = session.state_machine_lock.lock().unwrap();
     let state = session.state.read().unwrap();
@@ -1312,7 +1313,7 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
         timeout_trans(app, ctx, session, kex_lock, state, current_time, send)
     } else {
         let ts = state.resend_timer.load(Ordering::Relaxed);
-        let resend_next = current_time + App::SETTINGS.resend_time as i64;
+        let resend_next = current_time + Crypto::SETTINGS.resend_time as i64;
         if ts <= current_time && state.resend_timer.fetch_max(resend_next, Ordering::Relaxed) == ts {
             // Corresponds to the resend timer rules found in Section 4.1 - Definition 3.
 
@@ -1353,15 +1354,15 @@ pub(crate) fn process_timers<App: ApplicationLayer>(
     }
 }
 /// Corresponds to Transition Algorithm 7 found in Section 4.3.
-pub(crate) fn received_k1_trans<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
+pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    app: &mut App,
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Arc<Session<Crypto>>,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_NONCE_SIZE],
     k1: &mut [u8],
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) -> Result<(), ReceiveError<App::StorageError>> {
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
+) -> Result<(), ReceiveError> {
     use FaultType::*;
     //    -> s
     //    <- s
@@ -1391,7 +1392,7 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 
     let i = k1.len() - AES_GCM_TAG_SIZE;
     let tag = k1[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(
+    if !Crypto::Aead::decrypt_in_place(
         state.key_ref(false).recv.kek.as_ref().unwrap(),
         n,
         &[],
@@ -1407,9 +1408,9 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
 
     let result = (|| {
         let mut i = 0;
-        let mut noise = SymmetricState::<App>::initialize(PROTOCOL_NAME_NOISE_KK);
-        let hash = &mut App::Hash::new();
-        let hmac = &mut App::Hmac::new();
+        let mut noise = SymmetricState::<Crypto>::initialize(PROTOCOL_NAME_NOISE_KK);
+        let hash = &mut Crypto::Hash::new();
+        let hmac = &mut Crypto::Hmac::new();
         // Noise process prologue.
         noise.mix_hash(hash, &session.s_remote.to_bytes());
         noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
@@ -1466,8 +1467,8 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
                 deleted_state2: None,
             },
         );
-        if let Err(e) = result {
-            return Err(ReceiveError::StorageError(e));
+        if let Err(()) = result {
+            return Err(ReceiveError::RatchetStorageError);
         }
 
         let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
@@ -1489,8 +1490,8 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
             state.ratchet_state1 = new_ratchet_state.clone();
             let current_time = app.time();
             state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
-            let resend_timer = current_time + App::SETTINGS.resend_time as i64;
-            state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
+            let resend_timer = current_time + Crypto::SETTINGS.resend_time as i64;
+            state.timeout_timer = current_time + Crypto::SETTINGS.rekey_timeout as i64;
             state.resend_timer = AtomicI64::new(resend_timer);
             state.beta = ZetaAutomata::R2 { k2: k2.clone() };
             resend_timer
@@ -1515,15 +1516,15 @@ pub(crate) fn received_k1_trans<App: ApplicationLayer>(
     result
 }
 /// Corresponds to Transition Algorithm 8 found in Section 4.3.
-pub(crate) fn received_k2_trans<App: ApplicationLayer>(
-    app: &App,
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
+pub(crate) fn received_k2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
+    app: &mut App,
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Arc<Session<Crypto>>,
     kid: NonZeroU32,
     n: &[u8; AES_GCM_NONCE_SIZE],
     k2: &mut [u8],
-    send: impl FnOnce(&mut [u8], Option<&App::PrpEnc>),
-) -> Result<(), ReceiveError<App::StorageError>> {
+    send: impl FnOnce(&mut [u8], Option<&Crypto::PrpEnc>),
+) -> Result<(), ReceiveError> {
     use FaultType::*;
     //    <- e, ee, se
     if k2.len() != REKEY_SIZE {
@@ -1544,7 +1545,7 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
 
     let i = k2.len() - AES_GCM_TAG_SIZE;
     let tag = k2[i..].try_into().unwrap();
-    if !App::Aead::decrypt_in_place(
+    if !Crypto::Aead::decrypt_in_place(
         state.key_ref(false).recv.kek.as_ref().unwrap(),
         n,
         &[],
@@ -1561,8 +1562,8 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
         if let ZetaAutomata::R1 { noise, e_secret, .. } = &state.beta {
             let mut noise = noise.clone();
             let mut i = 0;
-            let hash = &mut App::Hash::new();
-            let hmac = &mut App::Hmac::new();
+            let hash = &mut Crypto::Hash::new();
+            let hmac = &mut Crypto::Hmac::new();
             // Process message pattern 2 e token.
             let e_remote = noise
                 .read_e_no_init(hash, hmac, &mut i, &k2)
@@ -1597,8 +1598,8 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
                     deleted_state2: state.ratchet_state2.as_ref(),
                 },
             );
-            if let Err(e) = result {
-                return Err(ReceiveError::StorageError(e));
+            if let Err(()) = result {
+                return Err(ReceiveError::RatchetStorageError);
             }
             let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
             let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
@@ -1618,8 +1619,8 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
                 state.key_index ^= true;
                 let current_time = app.time();
                 state.key_creation_counter = session.send_counter.load(Ordering::Relaxed);
-                let resend_timer = current_time + App::SETTINGS.resend_time as i64;
-                state.timeout_timer = current_time + App::SETTINGS.rekey_timeout as i64;
+                let resend_timer = current_time + Crypto::SETTINGS.resend_time as i64;
+                state.timeout_timer = current_time + Crypto::SETTINGS.rekey_timeout as i64;
                 state.resend_timer = AtomicI64::new(resend_timer);
                 state.beta = ZetaAutomata::S1;
                 resend_timer
@@ -1649,9 +1650,9 @@ pub(crate) fn received_k2_trans<App: ApplicationLayer>(
     result
 }
 /// Corresponds to Algorithm 9 found in Section 4.3.
-pub(crate) fn send_payload<App: ApplicationLayer>(
-    ctx: &Arc<ContextInner<App>>,
-    session: &Arc<Session<App>>,
+pub(crate) fn send_payload<Crypto: CryptoLayer>(
+    ctx: &Arc<ContextInner<Crypto>>,
+    session: &Arc<Session<Crypto>>,
     payload: &[u8],
     mut send: impl FnMut(&mut [u8]) -> bool,
     mtu_sized_buffer: &mut [u8],
@@ -1747,14 +1748,14 @@ pub(crate) fn send_payload<App: ApplicationLayer>(
     Ok(())
 }
 /// Corresponds to Algorithm 10 found in Section 4.3.
-pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
-    session: &Arc<Session<App>>,
-    state: RwLockReadGuard<'_, MutableState<App>>,
+pub(crate) fn receive_payload_in_place<Crypto: CryptoLayer>(
+    session: &Arc<Session<Crypto>>,
+    state: RwLockReadGuard<'_, MutableState<Crypto>>,
     kid: NonZeroU32,
     nonce: &[u8; AES_GCM_NONCE_SIZE],
-    fragments: &mut [App::IncomingPacketBuffer],
+    fragments: &mut [Crypto::IncomingPacketBuffer],
     mut output_buffer: impl Write,
-) -> Result<(), ReceiveError<App::StorageError>> {
+) -> Result<(), ReceiveError> {
     use FaultType::*;
     debug_assert!(!fragments.is_empty());
 
@@ -1804,12 +1805,12 @@ pub(crate) fn receive_payload_in_place<App: ApplicationLayer>(
     Ok(())
 }
 
-impl<App: ApplicationLayer> Drop for Session<App> {
+impl<Crypto: CryptoLayer> Drop for Session<Crypto> {
     fn drop(&mut self) {
         self.expire();
     }
 }
-impl<App: ApplicationLayer> Session<App> {
+impl<Crypto: CryptoLayer> Session<Crypto> {
     /// Mark a session as expired. This will make it impossible for this session to successfully
     /// receive or send data or control packets. It is recommended to simply `drop` the session
     /// instead, but this can provide some reassurance in complex shared ownership situations.
@@ -1823,8 +1824,8 @@ impl<App: ApplicationLayer> Session<App> {
     /// Allows us to expire sessions with the correct locking order, preventing deadlock.
     pub(crate) fn expire_inner(
         &self,
-        ctx: Option<&Arc<ContextInner<App>>>,
-        session_queue: Option<&mut SessionQueue<App>>,
+        ctx: Option<&Arc<ContextInner<Crypto>>>,
+        session_queue: Option<&mut SessionQueue<Crypto>>,
     ) {
         let _kex_lock = self.state_machine_lock.lock().unwrap();
         let mut state = self.state.write().unwrap();
@@ -1867,7 +1868,7 @@ impl<App: ApplicationLayer> Session<App> {
         )
     }
     /// The static public key of the remote peer.
-    pub fn remote_static_key(&self) -> &App::PublicKey {
+    pub fn remote_static_key(&self) -> &Crypto::PublicKey {
         &self.s_remote
     }
 }
diff --git a/src/zssp.rs b/src/zssp.rs
index 0acc741..16a40e5 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -37,31 +37,31 @@ pub(crate) use log;
 /// defragment incoming packets that are not yet associated with a session.
 ///
 /// Internally this is just a clonable Arc, so it can be safely shared with multiple threads.
-pub struct Context<Application: ApplicationLayer>(pub Arc<ContextInner<Application>>);
-impl<Application: ApplicationLayer> Clone for Context<Application> {
+pub struct Context<Crypto: CryptoLayer>(pub Arc<ContextInner<Crypto>>);
+impl<Crypto: CryptoLayer> Clone for Context<Crypto> {
     fn clone(&self) -> Self {
         Self(self.0.clone())
     }
 }
 
-pub(crate) type SessionMap<App> = RwLock<HashMap<NonZeroU32, Weak<Session<App>>>>;
-pub(crate) type SessionQueue<App> = IndexedBinaryHeap<Weak<Session<App>>, Reverse<i64>>;
-pub struct ContextInner<App: ApplicationLayer> {
-    pub rng: Mutex<App::Rng>,
-    pub(crate) s_secret: App::KeyPair,
+pub(crate) type SessionMap<Crypto> = RwLock<HashMap<NonZeroU32, Weak<Session<Crypto>>>>;
+pub(crate) type SessionQueue<Crypto> = IndexedBinaryHeap<Weak<Session<Crypto>>, Reverse<i64>>;
+pub struct ContextInner<Crypto: CryptoLayer> {
+    pub rng: Mutex<Crypto::Rng>,
+    pub(crate) s_secret: Crypto::KeyPair,
     /// `session_queue -> state_machine_lock -> state -> session_map`
-    pub(crate) session_queue: Mutex<SessionQueue<App>>,
+    pub(crate) session_queue: Mutex<SessionQueue<Crypto>>,
     /// `session_queue -> state_machine_lock -> state -> session_map`
-    pub(crate) session_map: SessionMap<App>,
-    pub(crate) unassociated_defrag_cache: Mutex<UnassociatedFragCache<App::IncomingPacketBuffer>>,
-    pub(crate) unassociated_handshake_states: UnassociatedHandshakeCache<App>,
+    pub(crate) session_map: SessionMap<Crypto>,
+    pub(crate) unassociated_defrag_cache: Mutex<UnassociatedFragCache<Crypto::IncomingPacketBuffer>>,
+    pub(crate) unassociated_handshake_states: UnassociatedHandshakeCache<Crypto>,
 
     pub(crate) challenge: ChallengeContext,
 }
 
-fn parse_fragment_header<StorageError>(
+fn parse_fragment_header(
     incoming_fragment: &[u8],
-) -> Result<(usize, usize, [u8; AES_GCM_NONCE_SIZE]), ReceiveError<StorageError>> {
+) -> Result<(usize, usize, [u8; AES_GCM_NONCE_SIZE]), ReceiveError> {
     let fragment_no = incoming_fragment[FRAGMENT_NO_IDX] as usize;
     let fragment_count = incoming_fragment[FRAGMENT_COUNT_IDX] as usize;
     if fragment_no >= fragment_count || fragment_count > MAX_FRAGMENTS {
@@ -110,9 +110,9 @@ fn send_with_fragmentation<PrpEnc: Aes256Enc>(
     true
 }
 
-impl<App: ApplicationLayer> Context<App> {
+impl<Crypto: CryptoLayer> Context<Crypto> {
     /// Create a new session context.
-    pub fn new(static_secret_key: App::KeyPair, mut rng: App::Rng) -> Self {
+    pub fn new(static_secret_key: Crypto::KeyPair, mut rng: Crypto::Rng) -> Self {
         let challenge = ChallengeContext::new(&mut rng);
         Self(Arc::new(ContextInner {
             rng: Mutex::new(rng),
@@ -141,15 +141,15 @@ impl<App: ApplicationLayer> Context<App> {
     ///   peer, or None if we do not have one.
     /// * `local_identity_blob` - Payload to be sent to Bob that contains the information necessary
     ///   for the upper protocol to authenticate and approve of Alice's identity.
-    pub fn open(
+    pub fn open<App: ApplicationLayer<Crypto = Crypto>>(
         &self,
         app: App,
         send: impl FnMut(&mut [u8]) -> bool,
         mut mtu: usize,
-        static_remote_key: App::PublicKey,
-        session_data: App::SessionData,
+        static_remote_key: Crypto::PublicKey,
+        session_data: Crypto::SessionData,
         identity: &[u8],
-    ) -> Result<Arc<Session<App>>, OpenError<App::StorageError>> {
+    ) -> Result<Arc<Session<Crypto>>, OpenError> {
         mtu = mtu.max(MIN_TRANSPORT_MTU);
         if identity.len() > IDENTITY_MAX_SIZE {
             return Err(OpenError::IdentityTooLarge);
@@ -198,16 +198,16 @@ impl<App: ApplicationLayer> Context<App> {
     /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
     ///   with the remote peer. Used to check the state of local offers we may currently have or want
     ///   to put in-flight.
-    pub fn receive<'a, SendFn: FnMut(&mut [u8]) -> bool>(
+    pub fn receive<'a, App: ApplicationLayer<Crypto = Crypto>, SendFn: FnMut(&mut [u8]) -> bool>(
         &self,
-        app: App,
+        mut app: App,
         mut send_unassociated_reply: impl FnMut(&mut [u8]) -> bool,
         mut send_unassociated_mtu: usize,
-        mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
+        mut send_to: impl FnMut(&Arc<Session<Crypto>>) -> Option<(SendFn, usize)>,
         remote_address: &impl Hash,
-        mut incoming_fragment_buf: App::IncomingPacketBuffer,
+        mut incoming_fragment_buf: Crypto::IncomingPacketBuffer,
         output_buffer: impl Write,
-    ) -> Result<ReceiveOk<App>, ReceiveError<App::StorageError>> {
+    ) -> Result<ReceiveOk<Crypto>, ReceiveError> {
         use crate::result::FaultType::*;
         let ctx = &self.0;
         send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
@@ -327,7 +327,7 @@ impl<App: ApplicationLayer> Context<App> {
                         &mut incoming_fragment_buf.as_mut()[HEADER_SIZE..]
                     };
 
-                    let send_associated = |packet: &mut [u8], hk_send: Option<&App::PrpEnc>| {
+                    let send_associated = |packet: &mut [u8], hk_send: Option<&Crypto::PrpEnc>| {
                         if let Some((send_fragment, mut mtu)) = send_to(&session) {
                             mtu = mtu.max(MIN_TRANSPORT_MTU);
                             send_with_fragmentation(send_fragment, mtu, packet, hk_send);
@@ -337,7 +337,7 @@ impl<App: ApplicationLayer> Context<App> {
                         PACKET_TYPE_HANDSHAKE_RESPONSE => {
                             log!(app, ReceivedRawX2);
                             let should_warn_missing_ratchet = received_x2_trans(
-                                &app,
+                                &mut app,
                                 ctx,
                                 &session,
                                 kid_recv,
@@ -355,7 +355,7 @@ impl<App: ApplicationLayer> Context<App> {
                         PACKET_TYPE_KEY_CONFIRM => {
                             log!(app, ReceivedRawKeyConfirm);
                             let just_established = received_c1_trans(
-                                &app,
+                                &mut app,
                                 ctx,
                                 &session,
                                 kid_recv,
@@ -372,14 +372,14 @@ impl<App: ApplicationLayer> Context<App> {
                         }
                         PACKET_TYPE_ACK => {
                             log!(app, ReceivedRawAck);
-                            received_c2_trans(&app, ctx, &session, kid_recv, &nonce, assembled_packet)?;
+                            received_c2_trans(&mut app, ctx, &session, kid_recv, &nonce, assembled_packet)?;
                             log!(app, AckIsAuth(&session));
                             SessionEvent::Control
                         }
                         PACKET_TYPE_REKEY_INIT => {
                             log!(app, ReceivedRawK1);
                             received_k1_trans(
-                                &app,
+                                &mut app,
                                 ctx,
                                 &session,
                                 kid_recv,
@@ -393,7 +393,7 @@ impl<App: ApplicationLayer> Context<App> {
                         PACKET_TYPE_REKEY_COMPLETE => {
                             log!(app, ReceivedRawK2);
                             received_k2_trans(
-                                &app,
+                                &mut app,
                                 ctx,
                                 &session,
                                 kid_recv,
@@ -418,7 +418,7 @@ impl<App: ApplicationLayer> Context<App> {
                 // Check for and handle PACKET_TYPE_ALICE_NOISE_XK_PATTERN_3
                 let zeta = self.0.unassociated_handshake_states.get(kid_recv);
                 if let Some(zeta) = zeta {
-                    App::PrpDec::new(&zeta.hk_recv).decrypt_in_place(
+                    Crypto::PrpDec::new(&zeta.hk_recv).decrypt_in_place(
                         (&mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
                             .try_into()
                             .unwrap(),
@@ -468,7 +468,7 @@ impl<App: ApplicationLayer> Context<App> {
 
                     log!(app, ReceivedRawX3);
                     let (session, should_warn_missing_ratchet) =
-                        received_x3_trans(&app, ctx, zeta, kid_recv, assembled_packet, |packet, hk_send| {
+                        received_x3_trans(&mut app, ctx, zeta, kid_recv, assembled_packet, |packet, hk_send| {
                             send_with_fragmentation(send_unassociated_reply, send_unassociated_mtu, packet, hk_send);
                         })?;
                     log!(app, X3IsAuthSentKeyConfirm(&session));
@@ -508,7 +508,7 @@ impl<App: ApplicationLayer> Context<App> {
                     incoming_fragment_buf,
                     fragment_no,
                     fragment_count,
-                    App::SETTINGS.resend_time as i64,
+                    Crypto::SETTINGS.resend_time as i64,
                     app.time(),
                     &mut fragment_buffer,
                 );
@@ -536,7 +536,7 @@ impl<App: ApplicationLayer> Context<App> {
                 }
                 // Process recv challenge layer.
                 let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
-                let hash = &mut App::Hash::new();
+                let hash = &mut Crypto::Hash::new();
                 match app.incoming_session() {
                     IncomingSessionAction::Allow => {}
                     IncomingSessionAction::Challenge => {
@@ -569,7 +569,7 @@ impl<App: ApplicationLayer> Context<App> {
 
                 // Process recv zeta layer.
                 received_x1_trans(
-                    &app,
+                    &mut app,
                     ctx,
                     hash,
                     &nonce,
@@ -612,7 +612,7 @@ impl<App: ApplicationLayer> Context<App> {
     /// * `current_time` - Current time in milliseconds
     pub fn send(
         &self,
-        session: &Arc<Session<App>>,
+        session: &Arc<Session<Crypto>>,
         send: impl FnMut(&mut [u8]) -> bool,
         mtu_sized_buffer: &mut [u8],
         data: &[u8],
@@ -631,15 +631,15 @@ impl<App: ApplicationLayer> Context<App> {
     ///   with remote peers (although both of these properties would help reliability slightly).
     ///   Used to determine if any current handshakes should be resent or timed-out, or if a session
     ///   should rekey.
-    pub fn service<SendFn: FnMut(&mut [u8]) -> bool>(
+    pub fn service<App: ApplicationLayer<Crypto = Crypto>, SendFn: FnMut(&mut [u8]) -> bool>(
         &self,
-        app: App,
-        mut send_to: impl FnMut(&Arc<Session<App>>) -> Option<(SendFn, usize)>,
+        mut app: App,
+        mut send_to: impl FnMut(&Arc<Session<Crypto>>) -> Option<(SendFn, usize)>,
     ) -> i64 {
         let ctx = &self.0;
         let mut session_queue = ctx.session_queue.lock().unwrap();
         let current_time = app.time();
-        let mut next_service_time = current_time + App::SETTINGS.fragment_assembly_timeout as i64;
+        let mut next_service_time = current_time + Crypto::SETTINGS.fragment_assembly_timeout as i64;
         // This update system takes heavy advantage of the fact that sessions only need to be updated
         // either roughly every second or roughly every hour. That big gap allows for minor optimizations.
         // If the gap changes (unlikely) this code may need to be rewritten.
@@ -655,7 +655,7 @@ impl<App: ApplicationLayer> Context<App> {
                     continue;
                 }
             };
-            let result = process_timers(&app, ctx, &session, current_time, |packet, hk_send| {
+            let result = process_timers(&mut app, ctx, &session, current_time, |packet, hk_send| {
                 if let Some((send_fragment, mut mtu)) = send_to(&session) {
                     mtu = mtu.max(MIN_TRANSPORT_MTU);
                     send_with_fragmentation(send_fragment, mtu, packet, hk_send);
@@ -674,7 +674,7 @@ impl<App: ApplicationLayer> Context<App> {
             .unassociated_defrag_cache
             .lock()
             .unwrap()
-            .check_for_expiry(App::SETTINGS.fragment_assembly_timeout as i64, current_time);
+            .check_for_expiry(Crypto::SETTINGS.fragment_assembly_timeout as i64, current_time);
         self.0.unassociated_handshake_states.service(current_time);
 
         next_service_time - current_time

From a22898d3486d7e639846dd09eb15edf27107c875 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 11:20:17 -0400
Subject: [PATCH 32/50] refortmatted

---
 examples/basic_test.rs | 15 +++----
 src/application.rs     | 12 +++---
 src/symmetric_state.rs | 15 ++++++-
 src/zeta.rs            | 91 ++++++++++++++++--------------------------
 src/zssp.rs            | 11 ++---
 5 files changed, 65 insertions(+), 79 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index f90a764..9d9bdc8 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -10,8 +10,8 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 
 use zssp::application::{
-    AcceptAction, CryptoLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate, Settings,
-    RATCHET_SIZE, ApplicationLayer,
+    AcceptAction, ApplicationLayer, CryptoLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate,
+    Settings, RATCHET_SIZE,
 };
 use zssp::crypto::P384KeyPair;
 use zssp::crypto_impl::*;
@@ -79,7 +79,11 @@ impl ApplicationLayer for &TestApplication {
         true
     }
 
-    fn check_accept_session(&mut self, remote_static_key: &P384CratePublicKey, identity: &[u8]) -> AcceptAction<TestApplication> {
+    fn check_accept_session(
+        &mut self,
+        remote_static_key: &P384CratePublicKey,
+        identity: &[u8],
+    ) -> AcceptAction<TestApplication> {
         AcceptAction {
             session_data: Some(1),
             responder_disallows_downgrade: true,
@@ -87,10 +91,7 @@ impl ApplicationLayer for &TestApplication {
         }
     }
 
-    fn restore_by_fingerprint(
-        &mut self,
-        ratchet_fingerprint: &[u8; RATCHET_SIZE],
-    ) -> Result<Option<RatchetState>, ()> {
+    fn restore_by_fingerprint(&mut self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, ()> {
         let ratchets = self.ratchets.lock().unwrap();
         Ok(ratchets.rf_map.get(ratchet_fingerprint).cloned())
     }
diff --git a/src/application.rs b/src/application.rs
index 05bb201..fe94c9f 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -129,7 +129,6 @@ pub trait CryptoLayer: Sized {
     /// for ZSSP to achieve FIPS compliance.
     type Kem: Kyber1024PrivateKey<Self::Rng>;
 
-
     /// Type for arbitrary opaque object for use by the application that is attached to
     /// each session.
     type SessionData;
@@ -185,7 +184,11 @@ pub trait ApplicationLayer: Sized {
     /// To prevent desync, if this function specifies that we should connect, no other open session
     /// with the same remote peer must exist. Drop or call expire on any pre-existing sessions
     /// before returning.
-    fn check_accept_session(&mut self, remote_static_key: &<Self::Crypto as CryptoLayer>::PublicKey, identity: &[u8]) -> AcceptAction<Self::Crypto>;
+    fn check_accept_session(
+        &mut self,
+        remote_static_key: &<Self::Crypto as CryptoLayer>::PublicKey,
+        identity: &[u8],
+    ) -> AcceptAction<Self::Crypto>;
 
     /// Lookup a specific ratchet state based on its ratchet fingerprint.
     /// This function will be called whenever Alice attempts to connect to us with a non-empty
@@ -193,10 +196,7 @@ pub trait ApplicationLayer: Sized {
     ///
     /// If a ratchet state with a matching fingerprint could not be found, this function should
     /// return `Ok(None)`.
-    fn restore_by_fingerprint(
-        &mut self,
-        ratchet_fingerprint: &[u8; RATCHET_SIZE],
-    ) -> Result<Option<RatchetState>, ()>;
+    fn restore_by_fingerprint(&mut self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, ()>;
     /// Lookup the specific ratchet states based on the identity of the peer being communicated with.
     /// This function will be called whenever Alice attempts to open a session, or Bob attempts
     /// to verify Alice's identity.
diff --git a/src/symmetric_state.rs b/src/symmetric_state.rs
index 5981e3c..c9ea5a8 100644
--- a/src/symmetric_state.rs
+++ b/src/symmetric_state.rs
@@ -138,7 +138,12 @@ impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
         self.k.clone_from_slice(&temp_k[..AES_256_KEY_SIZE]);
     }
     /// Corresponds to Noise `MixKeyAndHash`.
-    pub fn mix_key_and_hash_no_init(&mut self, hash: &mut Crypto::Hash, hmac: &mut Crypto::Hmac, input_key_material: &[u8]) {
+    pub fn mix_key_and_hash_no_init(
+        &mut self,
+        hash: &mut Crypto::Hash,
+        hmac: &mut Crypto::Hmac,
+        input_key_material: &[u8],
+    ) {
         let mut next_ck = Zeroizing::new([0u8; HASHLEN]);
         let mut temp_h = [0u8; HASHLEN];
 
@@ -194,7 +199,13 @@ impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
     /// is forward secrect and is cryptographically independent from all other produced keys.
     /// Based on Noise's unstable ASK mechanism, using KBKDF instead of HKDF.
     /// https://github.com/noiseprotocol/noise_wiki/wiki/Additional-Symmetric-Keys.
-    pub fn get_ask(&self, hmac: &mut Crypto::Hmac, label: &[u8; 4], key1: &mut [u8; HASHLEN], key2: &mut [u8; HASHLEN]) {
+    pub fn get_ask(
+        &self,
+        hmac: &mut Crypto::Hmac,
+        label: &[u8; 4],
+        key1: &mut [u8; HASHLEN],
+        key2: &mut [u8; HASHLEN],
+    ) {
         self.kbkdf(hmac, &self.h, label, 2, key1, Some(key2), None);
     }
     /// Used for internally debugging a key exchange.
diff --git a/src/zeta.rs b/src/zeta.rs
index 24c3dbf..068f964 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -188,7 +188,12 @@ impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
             None
         }
     }
-    fn mix_dh_no_init(&mut self, hmac: &mut Crypto::Hmac, secret: &Crypto::KeyPair, remote: &Crypto::PublicKey) -> Option<()> {
+    fn mix_dh_no_init(
+        &mut self,
+        hmac: &mut Crypto::Hmac,
+        secret: &Crypto::KeyPair,
+        remote: &Crypto::PublicKey,
+    ) -> Option<()> {
         let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
         if secret.agree(&remote, &mut ecdh_secret) {
             self.mix_key_no_init(hmac, ecdh_secret.as_ref());
@@ -251,7 +256,8 @@ fn get_counter<Crypto: CryptoLayer>(session: &Session<Crypto>, state: &MutableSt
             session.session_has_expired.store(true, Ordering::SeqCst);
             return None;
         }
-        Some((c, c > state.key_creation_counter + Crypto::SETTINGS.rekey_after_key_uses))
+        let rekey_at = state.key_creation_counter + Crypto::SETTINGS.rekey_after_key_uses;
+        Some((c, c > rekey_at))
     }
 }
 
@@ -330,13 +336,8 @@ fn create_a1_state<Crypto: CryptoLayer>(
 
     set_header(&mut x1, 0, &to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, c));
 
-    Some(Box::new(StateA1 {
-        noise,
-        e_secret,
-        e1_secret,
-        identity: identity.try_into().unwrap(),
-        x1,
-    }))
+    let identity = identity.try_into().unwrap();
+    Some(Box::new(StateA1 { noise, e_secret, e1_secret, identity, x1 }))
 }
 /// Corresponds to Transition Algorithm 1 found in Section 4.3.
 pub(crate) fn trans_to_a1<Crypto: CryptoLayer, App: ApplicationLayer<Crypto = Crypto>>(
@@ -430,12 +431,9 @@ pub(crate) fn respond_to_challenge<Crypto: CryptoLayer>(
     let mut state = session.state.write().unwrap();
     if let ZetaAutomata::A1(a1) = &mut state.beta {
         let response_start = a1.x1.len() - CHALLENGE_SIZE;
-        respond_to_challenge_in_place(
-            ctx.rng.lock().unwrap().deref_mut(),
-            &mut Crypto::Hash::new(),
-            challenge,
-            (&mut a1.x1[response_start..]).try_into().unwrap(),
-        );
+        let mut rng = ctx.rng.lock().unwrap();
+        let response = (&mut a1.x1[response_start..]).try_into().unwrap();
+        respond_to_challenge_in_place(rng.deref_mut(), &mut Crypto::Hash::new(), challenge, response);
     }
 }
 /// Corresponds to Transition Algorithm 2 found in Section 4.3.
@@ -718,7 +716,7 @@ pub(crate) fn received_x2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         } else {
             (state.ratchet_state2.as_ref(), Some(&state.ratchet_state1))
         };
-        let result = app.save_ratchet_state(
+        app.save_ratchet_state(
             &session.s_remote,
             &session.session_data,
             RatchetUpdate {
@@ -728,10 +726,8 @@ pub(crate) fn received_x2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                 deleted_state1: ratchet_to_delete,
                 deleted_state2: None,
             },
-        );
-        if let Err(()) = result {
-            return Err(ReceiveError::RatchetStorageError);
-        }
+        )
+        .map_err(|_| ReceiveError::RatchetStorageError)?;
 
         let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
         let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
@@ -871,12 +867,8 @@ pub(crate) fn received_x3_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         let mut d = ArrayVec::<u8, HEADERED_SESSION_REJECTED_SIZE>::new();
         d.extend([0u8; HEADER_SIZE]);
         let nonce = to_nonce(PACKET_TYPE_SESSION_REJECTED, c);
-        d.extend(Crypto::Aead::encrypt_in_place(
-            (&kek_send[..AES_256_KEY_SIZE]).try_into().unwrap(),
-            &nonce,
-            &[],
-            &mut [],
-        ));
+        let kek_send = (&kek_send[..AES_256_KEY_SIZE]).try_into().unwrap();
+        d.extend(Crypto::Aead::encrypt_in_place(kek_send, &nonce, &[], &mut []));
         set_header(&mut d, zeta.kid_send.get(), &nonce);
         d
     };
@@ -909,7 +901,7 @@ pub(crate) fn received_x3_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                 noise.split(hmac, &mut nk_send, &mut nk_recv);
 
                 // We must make sure the ratchet key is saved before we transition.
-                let result = app.save_ratchet_state(
+                app.save_ratchet_state(
                     &s_remote,
                     &session_data,
                     RatchetUpdate {
@@ -919,10 +911,8 @@ pub(crate) fn received_x3_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                         deleted_state1: Some(&state1),
                         deleted_state2: state2.as_ref(),
                     },
-                );
-                if let Err(()) = result {
-                    return Err(ReceiveError::RatchetStorageError);
-                }
+                )
+                .map_err(|_| ReceiveError::RatchetStorageError)?;
 
                 let session = {
                     let mut session_map = ctx.session_map.write().unwrap();
@@ -1037,7 +1027,7 @@ pub(crate) fn received_c1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     if is_other {
         if let ZetaAutomata::A3 { .. } | ZetaAutomata::R2 { .. } = &state.beta {
             if state.ratchet_state2.is_some() {
-                let result = app.save_ratchet_state(
+                app.save_ratchet_state(
                     &session.s_remote,
                     &session.session_data,
                     RatchetUpdate {
@@ -1047,21 +1037,16 @@ pub(crate) fn received_c1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                         deleted_state1: state.ratchet_state2.as_ref(),
                         deleted_state2: None,
                     },
-                );
-                if let Err(()) = result {
-                    return Err(ReceiveError::RatchetStorageError);
-                }
+                )
+                .map_err(|_| ReceiveError::RatchetStorageError)?;
             }
             drop(state);
             let timeout_timer = {
                 let mut state = session.state.write().unwrap();
                 state.ratchet_state2 = None;
                 state.key_index ^= true;
-                state.timeout_timer = app.time()
-                    + Crypto::SETTINGS
-                        .rekey_after_time
-                        .saturating_sub(ctx.rng.lock().unwrap().next_u64() % Crypto::SETTINGS.rekey_time_max_jitter)
-                        as i64;
+                let jitter = ctx.rng.lock().unwrap().next_u64() % Crypto::SETTINGS.rekey_time_max_jitter;
+                state.timeout_timer = app.time() + Crypto::SETTINGS.rekey_after_time.saturating_sub(jitter) as i64;
                 state.resend_timer = AtomicI64::new(i64::MAX);
                 state.beta = ZetaAutomata::S2;
                 state.timeout_timer
@@ -1122,11 +1107,8 @@ pub(crate) fn received_c2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     drop(state);
     let timeout_timer = {
         let mut state = session.state.write().unwrap();
-        state.timeout_timer = app.time()
-            + Crypto::SETTINGS
-                .rekey_after_time
-                .saturating_sub(ctx.rng.lock().unwrap().next_u64() % Crypto::SETTINGS.rekey_time_max_jitter)
-                as i64;
+        let jitter = ctx.rng.lock().unwrap().next_u64() % Crypto::SETTINGS.rekey_time_max_jitter;
+        state.timeout_timer = app.time() + Crypto::SETTINGS.rekey_after_time.saturating_sub(jitter) as i64;
         state.resend_timer = AtomicI64::new(i64::MAX);
         state.beta = ZetaAutomata::S2;
         state.timeout_timer
@@ -1456,7 +1438,7 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         k2.extend(tag);
 
         let new_ratchet_state = create_ratchet_state(hmac, &noise, state.ratchet_state1.chain_len);
-        let result = app.save_ratchet_state(
+        app.save_ratchet_state(
             &session.s_remote,
             &session.session_data,
             RatchetUpdate {
@@ -1466,10 +1448,8 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                 deleted_state1: state.ratchet_state2.as_ref(),
                 deleted_state2: None,
             },
-        );
-        if let Err(()) = result {
-            return Err(ReceiveError::RatchetStorageError);
-        }
+        )
+        .map_err(|_| ReceiveError::RatchetStorageError)?;
 
         let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
         let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
@@ -1587,7 +1567,7 @@ pub(crate) fn received_k2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                 .ok_or(byzantine_fault!(InvalidPacket, true))?;
 
             let new_ratchet_state = create_ratchet_state(hmac, &noise, state.ratchet_state1.chain_len);
-            let result = app.save_ratchet_state(
+            app.save_ratchet_state(
                 &session.s_remote,
                 &session.session_data,
                 RatchetUpdate {
@@ -1597,10 +1577,9 @@ pub(crate) fn received_k2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                     deleted_state1: Some(&state.ratchet_state1),
                     deleted_state2: state.ratchet_state2.as_ref(),
                 },
-            );
-            if let Err(()) = result {
-                return Err(ReceiveError::RatchetStorageError);
-            }
+            )
+            .map_err(|_| ReceiveError::RatchetStorageError)?;
+
             let mut kek_recv = Zeroizing::new([0u8; HASHLEN]);
             let mut kek_send = Zeroizing::new([0u8; HASHLEN]);
             let mut nk_recv = Zeroizing::new([0u8; HASHLEN]);
diff --git a/src/zssp.rs b/src/zssp.rs
index 16a40e5..03cfd22 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -59,9 +59,7 @@ pub struct ContextInner<Crypto: CryptoLayer> {
     pub(crate) challenge: ChallengeContext,
 }
 
-fn parse_fragment_header(
-    incoming_fragment: &[u8],
-) -> Result<(usize, usize, [u8; AES_GCM_NONCE_SIZE]), ReceiveError> {
+fn parse_fragment_header(incoming_fragment: &[u8]) -> Result<(usize, usize, [u8; AES_GCM_NONCE_SIZE]), ReceiveError> {
     let fragment_no = incoming_fragment[FRAGMENT_NO_IDX] as usize;
     let fragment_count = incoming_fragment[FRAGMENT_COUNT_IDX] as usize;
     if fragment_no >= fragment_count || fragment_count > MAX_FRAGMENTS {
@@ -223,11 +221,8 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
             let session = ctx.session_map.read().unwrap().get(&kid_recv).map(|r| r.upgrade());
             if let Some(Some(session)) = session {
                 let state = session.state.read().unwrap();
-                state.hk_recv.decrypt_in_place(
-                    (&mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END])
-                        .try_into()
-                        .unwrap(),
-                );
+                let header_auth = &mut incoming_fragment[HEADER_AUTH_START..HEADER_AUTH_END];
+                state.hk_recv.decrypt_in_place(header_auth.try_into().unwrap());
 
                 let (fragment_no, fragment_count, nonce) = parse_fragment_header(incoming_fragment)?;
                 let (packet_type, incoming_counter) = from_nonce(&nonce);

From 9de883f39303b3d0d331c56bc4a0905e3837061e Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 11:27:28 -0400
Subject: [PATCH 33/50] reformatted

---
 src/result.rs |   4 +-
 src/zeta.rs   | 171 +++++++++++++++++++++++++-------------------------
 src/zssp.rs   |  40 ++++++------
 3 files changed, 107 insertions(+), 108 deletions(-)

diff --git a/src/result.rs b/src/result.rs
index a972597..126b903 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -112,7 +112,7 @@ pub enum ReceiveError {
     IoError(std::io::Error),
 }
 
-macro_rules! byzantine_fault {
+macro_rules! fault {
     ($name:expr, $unnatural:ident) => {
         ReceiveError::ByzantineFault {
             #[cfg(feature = "debug")]
@@ -124,7 +124,7 @@ macro_rules! byzantine_fault {
         }
     };
 }
-pub(crate) use byzantine_fault;
+pub(crate) use fault;
 
 /// Result generated by the context packet receive function, with possible payloads.
 #[derive(Clone)]
diff --git a/src/zeta.rs b/src/zeta.rs
index 068f964..2eb7f5a 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -17,7 +17,7 @@ use crate::fragged::Fragged;
 use crate::indexed_heap::BinaryHeapIndex;
 use crate::proto::*;
 use crate::ratchet_state::{RatchetState, RatchetStates};
-use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, SendError};
+use crate::result::{fault, FaultType, OpenError, ReceiveError, SendError};
 use crate::symmetric_state::SymmetricState;
 use crate::zssp::{log, ContextInner, SessionQueue};
 #[cfg(feature = "logging")]
@@ -125,19 +125,17 @@ impl<Crypto: CryptoLayer> Default for DuplexKey<Crypto> {
 }
 impl<Crypto: CryptoLayer> DuplexKey<Crypto> {
     fn replace_nk(&mut self, nk_send: &[u8; HASHLEN], nk_recv: &[u8; HASHLEN]) {
-        self.nk = Some(Crypto::AeadPool::new(
-            (&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap(),
-            (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap(),
-        ))
+        let nk_send = (&nk_send[..AES_256_KEY_SIZE]).try_into().unwrap();
+        let nk_recv = (&nk_recv[..AES_256_KEY_SIZE]).try_into().unwrap();
+        self.nk = Some(Crypto::AeadPool::new(nk_send, nk_recv))
     }
 }
 impl Keys {
     fn replace_kek(&mut self, kek: &[u8; HASHLEN]) {
         // We want to give rust the best chance of implementing this in a way that does
         // not leak the key on the stack.
-        self.kek
-            .get_or_insert(Zeroizing::new([0u8; AES_256_KEY_SIZE]))
-            .copy_from_slice(&kek[..AES_256_KEY_SIZE]);
+        let old_kek = self.kek.get_or_insert(Zeroizing::new([0u8; AES_256_KEY_SIZE]));
+        old_kek.copy_from_slice(&kek[..AES_256_KEY_SIZE]);
     }
 }
 
@@ -151,6 +149,7 @@ impl<Crypto: CryptoLayer> MutableState<Crypto> {
 }
 
 impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
+    #[must_use]
     fn write_e_no_init<const CAP: usize>(
         &mut self,
         hash: &mut Crypto::Hash,
@@ -165,6 +164,7 @@ impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
         self.mix_key_no_init(hmac, &pub_key);
         e_secret
     }
+    #[must_use]
     fn read_e_no_init(
         &mut self,
         hash: &mut Crypto::Hash,
@@ -179,6 +179,7 @@ impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
         *i = j;
         Crypto::PublicKey::from_bytes((pub_key).try_into().unwrap())
     }
+    #[must_use]
     fn mix_dh(&mut self, hmac: &mut Crypto::Hmac, secret: &Crypto::KeyPair, remote: &Crypto::PublicKey) -> Option<()> {
         let mut ecdh_secret = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
         if secret.agree(&remote, &mut ecdh_secret) {
@@ -188,6 +189,7 @@ impl<Crypto: CryptoLayer> SymmetricState<Crypto> {
             None
         }
     }
+    #[must_use]
     fn mix_dh_no_init(
         &mut self,
         hmac: &mut Crypto::Hmac,
@@ -451,11 +453,11 @@ pub(crate) fn received_x1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     //    -> e, es, e1
     //    <- e, ee, ekem1, psk
     if !(HANDSHAKE_HELLO_MIN_SIZE..=HANDSHAKE_HELLO_MAX_SIZE).contains(&x1.len()) {
-        return Err(byzantine_fault!(InvalidPacket, true));
+        return Err(fault!(InvalidPacket, true));
     }
 
     if &n[AES_GCM_NONCE_SIZE - 8..] != &x1[x1.len() - 8..] {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
     let hmac = &mut Crypto::Hmac::new();
     let mut noise = SymmetricState::<Crypto>::initialize(PROTOCOL_NAME_NOISE_XK);
@@ -463,24 +465,24 @@ pub(crate) fn received_x1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     // Noise process prologue.
     let j = i + KID_SIZE;
     noise.mix_hash(hash, &x1[i..j]);
-    let kid_send = NonZeroU32::new(u32::from_ne_bytes(x1[i..j].try_into().unwrap()))
-        .ok_or(byzantine_fault!(InvalidPacket, true))?;
+    let kid_send =
+        NonZeroU32::new(u32::from_ne_bytes(x1[i..j].try_into().unwrap())).ok_or(fault!(InvalidPacket, true))?;
     noise.mix_hash(hash, &ctx.s_secret.public_key_bytes());
     i = j;
     // Process message pattern 1 e token.
     let e_remote = noise
         .read_e_no_init(hash, hmac, &mut i, &x1)
-        .ok_or(byzantine_fault!(FailedAuth, true))?;
+        .ok_or(fault!(FailedAuth, true))?;
     // Process message pattern 1 es token.
     noise
         .mix_dh(hmac, &ctx.s_secret, &e_remote)
-        .ok_or(byzantine_fault!(FailedAuth, true))?;
+        .ok_or(fault!(FailedAuth, true))?;
     // Process message pattern 1 e1 token.
     let j = i + KYBER_PUBLIC_KEY_SIZE;
     let k = j + AES_GCM_TAG_SIZE;
     let tag = x1[j..k].try_into().unwrap();
     if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 0), &mut x1[i..j], tag) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
     let e1_start = i;
     let e1_end = j;
@@ -490,7 +492,7 @@ pub(crate) fn received_x1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     let j = k - AES_GCM_TAG_SIZE;
     let tag = x1[j..k].try_into().unwrap();
     if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_HELLO, 1), &mut x1[i..j], tag) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
 
     let mut ratchet_state = None;
@@ -509,7 +511,7 @@ pub(crate) fn received_x1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         rs
     } else {
         if app.hello_requires_recognized_ratchet() {
-            return Err(byzantine_fault!(FailedAuth, true));
+            return Err(fault!(FailedAuth, true));
         }
         RatchetState::empty()
     };
@@ -525,7 +527,7 @@ pub(crate) fn received_x1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     // Process message pattern 2 ee token.
     noise
         .mix_dh(hmac, &e_secret, &e_remote)
-        .ok_or(byzantine_fault!(FailedAuth, true))?;
+        .ok_or(fault!(FailedAuth, true))?;
     // Process message pattern 2 ekem1 token.
     {
         let i = x2.len();
@@ -535,7 +537,7 @@ pub(crate) fn received_x1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
             (&x1[e1_start..e1_end]).try_into().unwrap(),
             &mut ekem1_secret,
         )
-        .ok_or(byzantine_fault!(FailedAuth, true))?;
+        .ok_or(fault!(FailedAuth, true))?;
         x2.extend(ekem1);
         let tag = noise.encrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..]);
         x2.extend(tag);
@@ -598,7 +600,7 @@ pub(crate) fn received_x2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     //    <- e, ee, ekem1, psk
     //    -> s, se
     if HANDSHAKE_RESPONSE_SIZE != x2.len() {
-        return Err(byzantine_fault!(InvalidPacket, true));
+        return Err(fault!(InvalidPacket, true));
     }
 
     let kex_lock = session.state_machine_lock.lock().unwrap();
@@ -607,42 +609,42 @@ pub(crate) fn received_x2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     let hmac = &mut Crypto::Hmac::new();
 
     if Some(kid) != state.key_ref(true).recv.kid {
-        return Err(byzantine_fault!(UnknownLocalKeyId, true));
+        return Err(fault!(UnknownLocalKeyId, true));
     }
     let (_, c) = from_nonce(n);
     if c >= COUNTER_WINDOW_MAX_SKIP_AHEAD || &n[AES_GCM_NONCE_SIZE - 3..] != &x2[x2.len() - 3..] {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
     let mut should_warn_missing_ratchet = false;
     let mut result = (|| {
         let a1 = if let ZetaAutomata::A1(a1) = &state.beta {
             a1
         } else {
-            return Err(byzantine_fault!(FailedAuth, true));
+            return Err(fault!(FailedAuth, true));
         };
         let mut noise = a1.noise.clone();
         let mut i = 0;
         // Process message pattern 2 e token.
         let e_remote = noise
             .read_e_no_init(hash, hmac, &mut i, &x2)
-            .ok_or(byzantine_fault!(FailedAuth, true))?;
+            .ok_or(fault!(FailedAuth, true))?;
         // Process message pattern 2 ee token.
         noise
             .mix_dh(hmac, &a1.e_secret, &e_remote)
-            .ok_or(byzantine_fault!(FailedAuth, true))?;
+            .ok_or(fault!(FailedAuth, true))?;
         // Process message pattern 2 ekem1 token.
         let j = i + KYBER_CIPHERTEXT_SIZE;
         let k = j + AES_GCM_TAG_SIZE;
         let tag = x2[j..k].try_into().unwrap();
         if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_RESPONSE, 0), &mut x2[i..j], tag) {
-            return Err(byzantine_fault!(FailedAuth, true));
+            return Err(fault!(FailedAuth, true));
         }
         let mut ekem1_secret = Zeroizing::new([0u8; KYBER_PLAINTEXT_SIZE]);
         if !a1
             .e1_secret
             .decapsulate((&x2[i..j]).try_into().unwrap(), &mut ekem1_secret)
         {
-            return Err(byzantine_fault!(FailedAuth, true));
+            return Err(fault!(FailedAuth, true));
         }
         noise.mix_key_no_init(hmac, ekem1_secret.as_ref());
         drop(ekem1_secret);
@@ -690,7 +692,7 @@ pub(crate) fn received_x2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
             }
         }
 
-        let (kid_send, mut noise) = result.ok_or(byzantine_fault!(FailedAuth, true))?;
+        let (kid_send, mut noise) = result.ok_or(fault!(FailedAuth, true))?;
 
         let mut x3 = ArrayVec::<u8, HEADERED_HANDSHAKE_COMPLETION_MAX_SIZE>::new();
         x3.extend([0u8; HEADER_SIZE]);
@@ -702,7 +704,7 @@ pub(crate) fn received_x2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         // Process message pattern 3 se token.
         noise
             .mix_dh(hmac, &ctx.s_secret, &e_remote)
-            .ok_or(byzantine_fault!(FailedAuth, true))?;
+            .ok_or(fault!(FailedAuth, true))?;
         // Process message pattern 3 payload.
         let i = x3.len();
         x3.try_extend_from_slice(&a1.identity).unwrap();
@@ -757,7 +759,7 @@ pub(crate) fn received_x2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                 a1
             } else {
                 // This return is unreachable.
-                return Err(byzantine_fault!(FailedAuth, true));
+                return Err(fault!(FailedAuth, true));
             };
             state.beta = ZetaAutomata::A3(Box::new(StateA3 { identity: a1.identity.clone(), x3: x3.clone() }));
             resend_timer
@@ -817,10 +819,10 @@ pub(crate) fn received_x3_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     use FaultType::*;
     //    -> s, se
     if x3.len() < HANDSHAKE_COMPLETION_MIN_SIZE {
-        return Err(byzantine_fault!(InvalidPacket, true));
+        return Err(fault!(InvalidPacket, true));
     }
     if kid != zeta.kid_recv {
-        return Err(byzantine_fault!(UnknownLocalKeyId, true));
+        return Err(fault!(UnknownLocalKeyId, true));
     }
     let hash = &mut Crypto::Hash::new();
     let hmac = &mut Crypto::Hmac::new();
@@ -832,21 +834,20 @@ pub(crate) fn received_x3_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     let k = j + AES_GCM_TAG_SIZE;
     let tag = x3[j..k].try_into().unwrap();
     if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 1), &mut x3[i..j], tag) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
-    let s_remote =
-        Crypto::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(byzantine_fault!(FailedAuth, true))?;
+    let s_remote = Crypto::PublicKey::from_bytes((&x3[i..j]).try_into().unwrap()).ok_or(fault!(FailedAuth, true))?;
     i = k;
     // Process message pattern 3 se token.
     noise
         .mix_dh(hmac, &zeta.e_secret, &s_remote)
-        .ok_or(byzantine_fault!(FailedAuth, true))?;
+        .ok_or(fault!(FailedAuth, true))?;
     // Process message pattern 3 payload.
     let k = x3.len();
     let j = k - AES_GCM_TAG_SIZE;
     let tag = x3[j..k].try_into().unwrap();
     if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_HANDSHAKE_COMPLETION, 0), &mut x3[i..j], tag) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
     let identity_start = i;
     let identity_end = j;
@@ -886,13 +887,13 @@ pub(crate) fn received_x3_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                         if !responder_silently_rejects {
                             send(&mut create_reject(), Some(&Crypto::PrpEnc::new(&zeta.hk_send)))
                         }
-                        return Err(byzantine_fault!(FailedAuth, true));
+                        return Err(fault!(FailedAuth, true));
                     }
                 }
 
                 let mut noise_kk_ss = Zeroizing::new([0u8; P384_ECDH_SHARED_SECRET_SIZE]);
                 if !ctx.s_secret.agree(&s_remote, &mut noise_kk_ss) {
-                    return Err(byzantine_fault!(FailedAuth, true));
+                    return Err(fault!(FailedAuth, true));
                 }
 
                 let new_ratchet_state = create_ratchet_state(hmac, &mut noise, zeta.ratchet_state.chain_len);
@@ -920,7 +921,7 @@ pub(crate) fn received_x3_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
                     let entry = match session_map.entry(zeta.kid_recv) {
                         // We could have issued the kid that we initially offered Alice to someone else
                         // before Alice was able to respond. It is unlikely but possible.
-                        Occupied(_) => return Err(byzantine_fault!(OutOfSequence, false)),
+                        Occupied(_) => return Err(fault!(OutOfSequence, false)),
                         Vacant(entry) => entry,
                     };
                     let mut session_queue = ctx.session_queue.lock().unwrap();
@@ -996,7 +997,7 @@ pub(crate) fn received_c1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     use FaultType::*;
 
     if c1.len() != KEY_CONFIRMATION_SIZE {
-        return Err(byzantine_fault!(InvalidPacket, true));
+        return Err(fault!(InvalidPacket, true));
     }
 
     let kex_lock = session.state_machine_lock.lock().unwrap();
@@ -1009,18 +1010,18 @@ pub(crate) fn received_c1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     } else {
         // Some key confirmation may have arrived extremely delayed.
         // It is unlikely but possible.
-        return Err(byzantine_fault!(OutOfSequence, false));
+        return Err(fault!(OutOfSequence, false));
     };
 
     let specified_key = state.key_ref(is_other).recv.kek.as_ref();
-    let specified_key = specified_key.ok_or(byzantine_fault!(OutOfSequence, true))?;
+    let specified_key = specified_key.ok_or(fault!(OutOfSequence, true))?;
     let tag = c1[..].try_into().unwrap();
     if !Crypto::Aead::decrypt_in_place(specified_key, n, &[], &mut [], tag) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
     if !session.window.update(c) {
-        return Err(byzantine_fault!(ExpiredCounter, true));
+        return Err(fault!(ExpiredCounter, true));
     }
 
     let just_establised = is_other && matches!(&state.beta, ZetaAutomata::A3 { .. });
@@ -1063,7 +1064,7 @@ pub(crate) fn received_c1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     let mut c2 = ArrayVec::<u8, HEADERED_ACKNOWLEDGEMENT_SIZE>::new();
     c2.extend([0u8; HEADER_SIZE]);
     if !send_control(session, &state, PACKET_TYPE_ACK, c2, send) {
-        return Err(byzantine_fault!(OutOfSequence, true));
+        return Err(fault!(OutOfSequence, true));
     }
 
     Ok(just_establised)
@@ -1081,7 +1082,7 @@ pub(crate) fn received_c2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     use FaultType::*;
 
     if c2.len() != ACKNOWLEDGEMENT_SIZE {
-        return Err(byzantine_fault!(InvalidPacket, true));
+        return Err(fault!(InvalidPacket, true));
     }
 
     let kex_lock = session.state_machine_lock.lock().unwrap();
@@ -1089,20 +1090,20 @@ pub(crate) fn received_c2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
 
     if Some(kid) != state.key_ref(false).recv.kid {
         // Some acknowledgement may have arrived extremely delayed.
-        return Err(byzantine_fault!(UnknownLocalKeyId, false));
+        return Err(fault!(UnknownLocalKeyId, false));
     }
     if !matches!(&state.beta, ZetaAutomata::S1) {
         // Some acknowledgement may have arrived extremely delayed.
-        return Err(byzantine_fault!(OutOfSequence, false));
+        return Err(fault!(OutOfSequence, false));
     }
 
     let tag = c2[..].try_into().unwrap();
     if !Crypto::Aead::decrypt_in_place(state.key_ref(false).recv.kek.as_ref().unwrap(), n, &[], &mut [], tag) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
     if !session.window.update(c) {
-        return Err(byzantine_fault!(ExpiredCounter, true));
+        return Err(fault!(ExpiredCounter, true));
     }
     drop(state);
     let timeout_timer = {
@@ -1131,23 +1132,23 @@ pub(crate) fn received_d_trans<Crypto: CryptoLayer>(
     use FaultType::*;
 
     if d.len() != SESSION_REJECTED_SIZE {
-        return Err(byzantine_fault!(InvalidPacket, true));
+        return Err(fault!(InvalidPacket, true));
     }
 
     let kex_lock = session.state_machine_lock.lock().unwrap();
     let state = session.state.read().unwrap();
 
     if Some(kid) != state.key_ref(true).recv.kid || !matches!(&state.beta, ZetaAutomata::A3 { .. }) {
-        return Err(byzantine_fault!(OutOfSequence, true));
+        return Err(fault!(OutOfSequence, true));
     }
 
     let tag = d[..].try_into().unwrap();
     if !Crypto::Aead::decrypt_in_place(state.key_ref(true).recv.kek.as_ref().unwrap(), n, &[], &mut [], tag) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
     if !session.window.update(c) {
-        return Err(byzantine_fault!(ExpiredCounter, true));
+        return Err(fault!(ExpiredCounter, true));
     }
 
     drop(state);
@@ -1352,7 +1353,7 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     //    -> psk, e, es, ss
     //    <- e, ee, se
     if k1.len() != REKEY_SIZE {
-        return Err(byzantine_fault!(InvalidPacket, true));
+        return Err(fault!(InvalidPacket, true));
     }
 
     let kex_lock = session.state_machine_lock.lock().unwrap();
@@ -1360,7 +1361,7 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
 
     if Some(kid) != state.key_ref(false).recv.kid {
         // Some rekey packet may have arrived extremely delayed.
-        return Err(byzantine_fault!(UnknownLocalKeyId, false));
+        return Err(fault!(UnknownLocalKeyId, false));
     }
     let should_rekey_as_bob = match &state.beta {
         ZetaAutomata::S2 { .. } => true,
@@ -1369,7 +1370,7 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     };
     if !should_rekey_as_bob {
         // Some rekey packet may have arrived extremely delayed.
-        return Err(byzantine_fault!(OutOfSequence, false));
+        return Err(fault!(OutOfSequence, false));
     }
 
     let i = k1.len() - AES_GCM_TAG_SIZE;
@@ -1381,11 +1382,11 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         &mut k1[..i],
         &tag,
     ) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
     if !session.window.update(c) {
-        return Err(byzantine_fault!(ExpiredCounter, true));
+        return Err(fault!(ExpiredCounter, true));
     }
 
     let result = (|| {
@@ -1401,11 +1402,11 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         // Process message pattern 1 e token.
         let e_remote = noise
             .read_e_no_init(hash, hmac, &mut i, &k1)
-            .ok_or(byzantine_fault!(FailedAuth, true))?;
+            .ok_or(fault!(FailedAuth, true))?;
         // Process message pattern 1 es token.
         noise
             .mix_dh_no_init(hmac, &ctx.s_secret, &e_remote)
-            .ok_or(byzantine_fault!(FailedAuth, true))?;
+            .ok_or(fault!(FailedAuth, true))?;
         // Process message pattern 1 ss token.
         noise.mix_key(hmac, session.noise_kk_ss.as_ref());
         // Process message pattern 1 payload.
@@ -1413,10 +1414,10 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         let k = j + AES_GCM_TAG_SIZE;
         let tag = k1[j..k].try_into().unwrap();
         if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_INIT, 0), &mut k1[i..j], tag) {
-            return Err(byzantine_fault!(FailedAuth, true));
+            return Err(fault!(FailedAuth, true));
         }
-        let kid_send = NonZeroU32::new(u32::from_ne_bytes(k1[i..j].try_into().unwrap()))
-            .ok_or(byzantine_fault!(FailedAuth, true))?;
+        let kid_send =
+            NonZeroU32::new(u32::from_ne_bytes(k1[i..j].try_into().unwrap())).ok_or(fault!(FailedAuth, true))?;
 
         let mut k2 = ArrayVec::<u8, HEADERED_REKEY_SIZE>::new();
         k2.extend([0u8; HEADER_SIZE]);
@@ -1425,11 +1426,11 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         // Process message pattern 2 ee token.
         noise
             .mix_dh_no_init(hmac, &e_secret, &e_remote)
-            .ok_or(byzantine_fault!(FailedAuth, true))?;
+            .ok_or(fault!(FailedAuth, true))?;
         // Process message pattern 2 se token.
         noise
             .mix_dh(hmac, &ctx.s_secret, &e_remote)
-            .ok_or(byzantine_fault!(FailedAuth, true))?;
+            .ok_or(fault!(FailedAuth, true))?;
         // Process message pattern 2 payload.
         let i = k2.len();
         let new_kid_recv = remap(ctx, session, &state);
@@ -1484,7 +1485,7 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         let state = session.state.read().unwrap();
 
         if !send_control(session, &state, PACKET_TYPE_REKEY_COMPLETE, k2, send) {
-            return Err(byzantine_fault!(OutOfSequence, true));
+            return Err(fault!(OutOfSequence, true));
         }
 
         Ok(())
@@ -1508,7 +1509,7 @@ pub(crate) fn received_k2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
     use FaultType::*;
     //    <- e, ee, se
     if k2.len() != REKEY_SIZE {
-        return Err(byzantine_fault!(InvalidPacket, true));
+        return Err(fault!(InvalidPacket, true));
     }
 
     let kex_lock = session.state_machine_lock.lock().unwrap();
@@ -1516,11 +1517,11 @@ pub(crate) fn received_k2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
 
     if Some(kid) != state.key_ref(false).recv.kid {
         // Some rekey packet may have arrived extremely delayed.
-        return Err(byzantine_fault!(UnknownLocalKeyId, false));
+        return Err(fault!(UnknownLocalKeyId, false));
     }
     if !matches!(&state.beta, ZetaAutomata::R1 { .. }) {
         // Some rekey packet may have arrived extremely delayed.
-        return Err(byzantine_fault!(OutOfSequence, false));
+        return Err(fault!(OutOfSequence, false));
     }
 
     let i = k2.len() - AES_GCM_TAG_SIZE;
@@ -1532,11 +1533,11 @@ pub(crate) fn received_k2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
         &mut k2[..i],
         &tag,
     ) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
     if !session.window.update(c) {
-        return Err(byzantine_fault!(ExpiredCounter, true));
+        return Err(fault!(ExpiredCounter, true));
     }
     let result = (|| {
         if let ZetaAutomata::R1 { noise, e_secret, .. } = &state.beta {
@@ -1547,24 +1548,24 @@ pub(crate) fn received_k2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
             // Process message pattern 2 e token.
             let e_remote = noise
                 .read_e_no_init(hash, hmac, &mut i, &k2)
-                .ok_or(byzantine_fault!(FailedAuth, true))?;
+                .ok_or(fault!(FailedAuth, true))?;
             // Process message pattern 2 ee token.
             noise
                 .mix_dh_no_init(hmac, e_secret, &e_remote)
-                .ok_or(byzantine_fault!(FailedAuth, true))?;
+                .ok_or(fault!(FailedAuth, true))?;
             // Process message pattern 2 se token.
             noise
                 .mix_dh(hmac, e_secret, &session.s_remote)
-                .ok_or(byzantine_fault!(FailedAuth, true))?;
+                .ok_or(fault!(FailedAuth, true))?;
             // Process message pattern 2 payload.
             let j = i + KID_SIZE;
             let k = j + AES_GCM_TAG_SIZE;
             let tag = k2[j..k].try_into().unwrap();
             if !noise.decrypt_and_hash_in_place(hash, to_nonce(PACKET_TYPE_REKEY_COMPLETE, 0), &mut k2[i..j], tag) {
-                return Err(byzantine_fault!(FailedAuth, true));
+                return Err(fault!(FailedAuth, true));
             }
-            let kid_send = NonZeroU32::new(u32::from_ne_bytes(k2[i..j].try_into().unwrap()))
-                .ok_or(byzantine_fault!(InvalidPacket, true))?;
+            let kid_send =
+                NonZeroU32::new(u32::from_ne_bytes(k2[i..j].try_into().unwrap())).ok_or(fault!(InvalidPacket, true))?;
 
             let new_ratchet_state = create_ratchet_state(hmac, &noise, state.ratchet_state1.chain_len);
             app.save_ratchet_state(
@@ -1614,7 +1615,7 @@ pub(crate) fn received_k2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
             let mut c1 = ArrayVec::<u8, HEADERED_KEY_CONFIRMATION_SIZE>::new();
             c1.extend([0u8; HEADER_SIZE]);
             if !send_control(&session, &state, PACKET_TYPE_KEY_CONFIRM, c1, send) {
-                return Err(byzantine_fault!(OutOfSequence, true));
+                return Err(fault!(OutOfSequence, true));
             }
 
             Ok(())
@@ -1744,12 +1745,10 @@ pub(crate) fn receive_payload_in_place<Crypto: CryptoLayer>(
         state.keys[1].nk.as_ref()
     } else {
         // Should be unreachable unless we are leaking kids somewhere.
-        return Err(byzantine_fault!(UnknownLocalKeyId, true));
+        return Err(fault!(UnknownLocalKeyId, true));
     };
 
-    let mut cipher = specified_key
-        .ok_or(byzantine_fault!(OutOfSequence, true))?
-        .start_dec(nonce);
+    let mut cipher = specified_key.ok_or(fault!(OutOfSequence, true))?.start_dec(nonce);
     let (_, c) = from_nonce(nonce);
 
     // NOTE: This only works because we check the size of every received fragment in the receive
@@ -1765,13 +1764,13 @@ pub(crate) fn receive_payload_in_place<Crypto: CryptoLayer>(
     cipher.decrypt_in_place(&mut fragment[..tag_idx]);
 
     if !cipher.finish((&fragment[tag_idx..]).try_into().unwrap()) {
-        return Err(byzantine_fault!(FailedAuth, true));
+        return Err(fault!(FailedAuth, true));
     }
 
     if !session.window.update(c) {
         // This error is marked as not happening naturally, but it could occur if something about
         // the transport protocol is duplicating packets.
-        return Err(byzantine_fault!(ExpiredCounter, true));
+        return Err(fault!(ExpiredCounter, true));
     }
 
     for fragment in fragments {
diff --git a/src/zssp.rs b/src/zssp.rs
index 03cfd22..7ba3b41 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -18,7 +18,7 @@ use crate::fragged::Assembled;
 use crate::handshake_cache::UnassociatedHandshakeCache;
 use crate::indexed_heap::IndexedBinaryHeap;
 use crate::proto::*;
-use crate::result::{byzantine_fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError, SessionEvent};
+use crate::result::{fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError, SessionEvent};
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
 
@@ -63,7 +63,7 @@ fn parse_fragment_header(incoming_fragment: &[u8]) -> Result<(usize, usize, [u8;
     let fragment_no = incoming_fragment[FRAGMENT_NO_IDX] as usize;
     let fragment_count = incoming_fragment[FRAGMENT_COUNT_IDX] as usize;
     if fragment_no >= fragment_count || fragment_count > MAX_FRAGMENTS {
-        return Err(byzantine_fault!(FaultType::InvalidPacket, true));
+        return Err(fault!(FaultType::InvalidPacket, true));
     }
     let mut nonce = [0u8; AES_GCM_NONCE_SIZE];
     nonce[2..].copy_from_slice(&incoming_fragment[PACKET_NONCE_START..HEADER_SIZE]);
@@ -211,7 +211,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
         send_unassociated_mtu = send_unassociated_mtu.max(MIN_TRANSPORT_MTU);
         let incoming_fragment: &mut [u8] = incoming_fragment_buf.as_mut();
         if incoming_fragment.len() < MIN_PACKET_SIZE {
-            return Err(byzantine_fault!(FaultType::InvalidPacket, false));
+            return Err(fault!(FaultType::InvalidPacket, false));
         }
 
         let mut fragment_buffer = Assembled::new();
@@ -239,10 +239,10 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                         if !matches!(&state.beta, ZetaAutomata::A1(_)) {
                             // A resent handshake response from Bob may have arrived out of order,
                             // after we already received one.
-                            return Err(byzantine_fault!(OutOfSequence, false));
+                            return Err(fault!(OutOfSequence, false));
                         }
                         if incoming_counter >= COUNTER_WINDOW_MAX_SKIP_AHEAD {
-                            return Err(byzantine_fault!(ExpiredCounter, true));
+                            return Err(fault!(ExpiredCounter, true));
                         }
                     } else if PACKET_TYPE_USES_COUNTER_RANGE.contains(&packet_type) {
                         // For DOS resistant reply-protection we need to check that the given counter is
@@ -258,14 +258,14 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                             // received the first session key and is reject all of Alice's resends.
                             // This can also occur if a session was manually expired, but not
                             // dropped, and the remote party is still sending us data.
-                            return Err(byzantine_fault!(ExpiredCounter, false));
+                            return Err(fault!(ExpiredCounter, false));
                         }
                     } else if packet_type == PACKET_TYPE_HANDSHAKE_COMPLETION {
                         // This can be triggered if Bob successfully received a session key and
                         // needs to reject all of Alice's resends of PACKET_TYPE_NOISE_XK_PATTERN_3.
-                        return Err(byzantine_fault!(InvalidPacket, false));
+                        return Err(fault!(InvalidPacket, false));
                     } else {
-                        return Err(byzantine_fault!(InvalidPacket, true));
+                        return Err(fault!(InvalidPacket, true));
                     }
                 }
 
@@ -312,7 +312,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                             for fragment in fragment_buffer.as_ref() {
                                 buffer
                                     .try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..])
-                                    .map_err(|_| byzantine_fault!(InvalidPacket, true))?;
+                                    .map_err(|_| fault!(InvalidPacket, true))?;
                             }
                             // We have not yet authenticated the sender so we do not report
                             // receiving a packet from them.
@@ -405,7 +405,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                             log!(app, DIsAuthClosedSession(&session));
                             SessionEvent::Rejected
                         }
-                        _ => return Err(byzantine_fault!(InvalidPacket, true)), // This is unreachable.
+                        _ => return Err(fault!(InvalidPacket, true)), // This is unreachable.
                     }
                 };
                 Ok(ReceiveOk::Session(session, ret))
@@ -429,7 +429,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                     {
                         //vrfy
                         if packet_type != PACKET_TYPE_HANDSHAKE_COMPLETION || incoming_counter != 0 {
-                            return Err(byzantine_fault!(InvalidPacket, true));
+                            return Err(fault!(InvalidPacket, true));
                         }
                     }
 
@@ -448,7 +448,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                             for fragment in fragment_buffer.as_ref() {
                                 buffer
                                     .try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..])
-                                    .map_err(|_| byzantine_fault!(InvalidPacket, true))?;
+                                    .map_err(|_| fault!(InvalidPacket, true))?;
                             }
                             buffer.as_mut()
                         }
@@ -479,7 +479,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                     // This can occur naturally because either Bob's incoming_sessions cache got
                     // full so Alice's incoming session was dropped, or the session this packet
                     // was for was dropped by the application.
-                    return Err(byzantine_fault!(UnknownLocalKeyId, false));
+                    return Err(fault!(UnknownLocalKeyId, false));
                 }
             }
         } else {
@@ -490,7 +490,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
             {
                 //vrfy
                 if packet_type != PACKET_TYPE_HANDSHAKE_HELLO && packet_type != PACKET_TYPE_CHALLENGE {
-                    return Err(byzantine_fault!(InvalidPacket, true));
+                    return Err(fault!(InvalidPacket, true));
                 }
             }
 
@@ -513,7 +513,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                     for fragment in fragment_buffer.as_ref() {
                         buffer
                             .try_extend_from_slice(&fragment.as_ref()[HEADER_SIZE..])
-                            .map_err(|_| byzantine_fault!(InvalidPacket, true))?;
+                            .map_err(|_| fault!(InvalidPacket, true))?;
                     }
                     buffer.as_mut()
                 }
@@ -527,7 +527,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                 if !(HANDSHAKE_HELLO_CHALLENGE_MIN_SIZE..=HANDSHAKE_HELLO_CHALLENGE_MAX_SIZE)
                     .contains(&assembled_packet.len())
                 {
-                    return Err(byzantine_fault!(InvalidPacket, true));
+                    return Err(fault!(InvalidPacket, true));
                 }
                 // Process recv challenge layer.
                 let challenge_start = assembled_packet.len() - CHALLENGE_SIZE;
@@ -554,7 +554,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
 
                             send_unassociated_reply(&mut challenge_packet);
                             // If we issue a challenge the first hello packet will always fail.
-                            return Err(byzantine_fault!(FailedAuth, false));
+                            return Err(fault!(FailedAuth, false));
                         } else {
                             log!(app, X1SucceededChallenge);
                         }
@@ -580,7 +580,7 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                 log!(app, ReceivedRawChallenge);
                 // Process recv challenge layer.
                 if assembled_packet.len() != KID_SIZE + CHALLENGE_SIZE {
-                    return Err(byzantine_fault!(InvalidPacket, true));
+                    return Err(fault!(InvalidPacket, true));
                 }
                 if let Some(kid_recv) =
                     NonZeroU32::new(u32::from_ne_bytes(assembled_packet[..KID_SIZE].try_into().unwrap()))
@@ -591,9 +591,9 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                         return Ok(ReceiveOk::Unassociated);
                     }
                 }
-                Err(byzantine_fault!(UnknownLocalKeyId, true))
+                Err(fault!(UnknownLocalKeyId, true))
             } else {
-                Err(byzantine_fault!(InvalidPacket, true))
+                Err(fault!(InvalidPacket, true))
             }
         }
     }

From 77d2d0f4f1cb8a91bee7d2575480faff84b0dc66 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 12:02:57 -0400
Subject: [PATCH 34/50] reformatted imports

---
 src/zeta.rs | 5 +++--
 src/zssp.rs | 1 -
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/zeta.rs b/src/zeta.rs
index 2eb7f5a..59abe4c 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -1,5 +1,3 @@
-use arrayvec::ArrayVec;
-use rand_core::RngCore;
 use std::cmp::Reverse;
 use std::collections::HashMap;
 use std::io::Write;
@@ -7,6 +5,9 @@ use std::num::NonZeroU32;
 use std::ops::{Deref, DerefMut};
 use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockReadGuard, Weak};
+
+use arrayvec::ArrayVec;
+use rand_core::RngCore;
 use zeroize::Zeroizing;
 
 use crate::antireplay::Window;
diff --git a/src/zssp.rs b/src/zssp.rs
index 7ba3b41..7190c3a 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -11,7 +11,6 @@ use rand_core::RngCore;
 use crate::challenge::ChallengeContext;
 use crate::crypto::*;
 use crate::zeta::*;
-
 use crate::application::*;
 use crate::frag_cache::UnassociatedFragCache;
 use crate::fragged::Assembled;

From 91c00f318b1d2a2286ff4832ebfdb77b131c5cc0 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 12:25:33 -0400
Subject: [PATCH 35/50] added benchmark

---
 examples/basic_test.rs |   2 +-
 examples/benchmark.rs  | 314 +++++++++++++++++++++++++++++++++++++++++
 src/application.rs     |   3 +-
 src/zeta.rs            |   2 +-
 src/zssp.rs            |   7 +-
 5 files changed, 322 insertions(+), 6 deletions(-)
 create mode 100644 examples/benchmark.rs

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 9d9bdc8..11e5d0b 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -68,7 +68,7 @@ impl ApplicationLayer for &TestApplication {
     type Crypto = TestApplication;
 
     fn incoming_session(&mut self) -> IncomingSessionAction {
-        IncomingSessionAction::Allow
+        IncomingSessionAction::Challenge
     }
 
     fn hello_requires_recognized_ratchet(&mut self) -> bool {
diff --git a/examples/benchmark.rs b/examples/benchmark.rs
new file mode 100644
index 0000000..52ce563
--- /dev/null
+++ b/examples/benchmark.rs
@@ -0,0 +1,314 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{mpsc, Arc};
+use std::thread;
+use std::time::{Duration, Instant};
+
+use arrayvec::ArrayVec;
+use rand_core::OsRng;
+use rand_core::RngCore;
+
+use zssp::application::{
+    AcceptAction, ApplicationLayer, CryptoLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate,
+    RATCHET_SIZE,
+};
+use zssp::crypto::P384KeyPair;
+use zssp::crypto_impl::*;
+use zssp::result::ReceiveError;
+use zssp::Session;
+
+const TEST_MTU: usize = 1500;
+
+struct TestApplication {
+    time: Instant,
+}
+
+#[allow(unused)]
+impl CryptoLayer for TestApplication {
+    type Rng = OsRng;
+    type PrpEnc = Aes256OpenSSLEnc;
+    type PrpDec = Aes256OpenSSLDec;
+    type Aead = AesGcmOpenSSL;
+    type AeadPool = AesGcmOpenSSLPool;
+    type Hash = Sha512Crate;
+    type Hmac = HmacSha512Crate;
+    type PublicKey = P384CratePublicKey;
+    type KeyPair = P384CrateKeyPair;
+    type Kem = RustKyber1024PrivateKey;
+
+    type SessionData = ();
+
+    type IncomingPacketBuffer = Vec<u8>;
+}
+#[allow(unused)]
+impl ApplicationLayer for &TestApplication {
+    type Crypto = TestApplication;
+
+    fn incoming_session(&mut self) -> IncomingSessionAction {
+        IncomingSessionAction::Allow
+    }
+
+    fn hello_requires_recognized_ratchet(&mut self) -> bool {
+        false
+    }
+
+    fn initiator_disallows_downgrade(&mut self, session: &Arc<Session<TestApplication>>) -> bool {
+        false
+    }
+
+    fn check_accept_session(
+        &mut self,
+        remote_static_key: &P384CratePublicKey,
+        identity: &[u8],
+    ) -> AcceptAction<TestApplication> {
+        AcceptAction {
+            session_data: Some(()),
+            responder_disallows_downgrade: true,
+            responder_silently_rejects: false,
+        }
+    }
+
+    fn restore_by_fingerprint(&mut self, ratchet_fingerprint: &[u8; RATCHET_SIZE]) -> Result<Option<RatchetState>, ()> {
+        Ok(None)
+    }
+
+    fn restore_by_identity(
+        &mut self,
+        remote_static_key: &P384CratePublicKey,
+        session_data: &(),
+    ) -> Result<Option<RatchetStates>, ()> {
+        Ok(None)
+    }
+
+    fn save_ratchet_state(
+        &mut self,
+        remote_static_key: &P384CratePublicKey,
+        session_data: &(),
+        update_data: RatchetUpdate<'_>,
+    ) -> Result<(), ()> {
+        Ok(())
+    }
+
+    fn time(&mut self) -> i64 {
+        self.time.elapsed().as_millis() as i64
+    }
+}
+
+#[allow(unused)]
+fn alice_main(
+    run: &AtomicBool,
+    alice_app: &TestApplication,
+    alice_out: mpsc::SyncSender<Vec<u8>>,
+    alice_in: mpsc::Receiver<Vec<u8>>,
+    alice_keypair: P384CrateKeyPair,
+    bob_pubkey: P384CratePublicKey,
+) {
+    let startup_time = std::time::Instant::now();
+    let context = zssp::Context::<TestApplication>::new(alice_keypair, OsRng);
+    let mut next_service = startup_time.elapsed().as_millis() as i64 + 500;
+    let test_data = [1u8; TEST_MTU * 10];
+    let mut up = false;
+
+    let alice_session = Some(
+        context
+            .open(
+                alice_app,
+                |b| alice_out.send(b.to_vec()).is_ok(),
+                TEST_MTU,
+                bob_pubkey.clone(),
+                (),
+                &[],
+            )
+            .unwrap(),
+    );
+    println!("[alice] opening session");
+    while run.load(Ordering::Relaxed) {
+        let current_time = startup_time.elapsed().as_millis() as i64;
+        loop {
+            let pkt = alice_in.try_recv();
+            if let Ok(pkt) = pkt {
+                use zssp::result::ReceiveOk::*;
+                use zssp::result::SessionEvent::*;
+                let mut output_data = Vec::new();
+                match context.receive(
+                    alice_app,
+                    |b| alice_out.send(b.to_vec()).is_ok(),
+                    TEST_MTU,
+                    |_| Some((|b: &mut [u8]| alice_out.send(b.to_vec()).is_ok(), TEST_MTU)),
+                    &0,
+                    pkt,
+                    &mut output_data,
+                ) {
+                    Ok(Unassociated) => {
+                        //println!("[alice] ok");
+                    }
+                    Ok(Session(_, event)) => match event {
+                        Established => {
+                            up = true;
+                        }
+                        Data => {
+                            assert!(!output_data.is_empty());
+                            //println!("[alice] received {}", data.len());
+                        }
+                        Control => (),
+                        _ => panic!(),
+                    },
+                    Err(e) => {
+                        println!("[alice] ERROR {:?}", e);
+                        if let ReceiveError::ByzantineFault { unnatural, .. } = e {
+                            assert!(!unnatural)
+                        }
+                    }
+                }
+            } else {
+                break;
+            }
+        }
+
+        if up {
+            context
+                .send(
+                    alice_session.as_ref().unwrap(),
+                    |b| alice_out.send(b.to_vec()).is_ok(),
+                    &mut [0u8; TEST_MTU],
+                    &test_data[..1400 + ((OsRng.next_u64() as usize) % (test_data.len() - 1400))],
+                )
+                .unwrap();
+        } else {
+            thread::sleep(Duration::from_millis(10));
+        }
+
+        if current_time >= next_service {
+            next_service = current_time
+                + context.service(alice_app, |_| {
+                    Some((|b: &mut [u8]| alice_out.send(b.to_vec()).is_ok(), TEST_MTU))
+                });
+        }
+    }
+}
+
+#[allow(unused)]
+fn bob_main(
+    run: &AtomicBool,
+    bob_app: &TestApplication,
+    bob_out: mpsc::SyncSender<Vec<u8>>,
+    bob_in: mpsc::Receiver<Vec<u8>>,
+    bob_keypair: P384CrateKeyPair,
+) {
+    let startup_time = std::time::Instant::now();
+    let context = zssp::Context::<TestApplication>::new(bob_keypair, OsRng);
+    let mut last_speed_metric = startup_time.elapsed().as_millis() as i64;
+    let mut next_service = last_speed_metric + 500;
+    let mut transferred = 0u64;
+    let mut output_data = ArrayVec::<u8, 15000>::new();
+
+    let mut bob_session = None;
+
+    while run.load(Ordering::Relaxed) {
+        let pkt = bob_in.recv_timeout(Duration::from_millis(100));
+        let current_time = startup_time.elapsed().as_millis() as i64;
+
+        if let Ok(pkt) = pkt {
+            use zssp::result::ReceiveOk::*;
+            use zssp::result::SessionEvent::*;
+            match context.receive(
+                bob_app,
+                |b| bob_out.send(b.to_vec()).is_ok(),
+                TEST_MTU,
+                |_| Some((|b: &mut [u8]| bob_out.send(b.to_vec()).is_ok(), TEST_MTU)),
+                &0,
+                pkt,
+                &mut output_data,
+            ) {
+                Ok(Unassociated) => {}
+                Ok(Session(s, event)) => match event {
+                    NewSession | NewDowngradedSession => {
+                        println!("[bob] new session, took {}s", current_time as f32 / 1000.0);
+                        let _ = bob_session.replace(s);
+                    }
+                    Data => {
+                        assert!(!output_data.is_empty());
+                        //println!("[bob] received {}", output_data.len());
+                        transferred += output_data.len() as u64 * 2; // *2 because we are also sending this many bytes back
+                        context
+                            .send(
+                                &s,
+                                |b| bob_out.send(b.to_vec()).is_ok(),
+                                &mut [0u8; TEST_MTU],
+                                &output_data,
+                            )
+                            .unwrap();
+                    }
+                    Control => (),
+                    _ => panic!(),
+                },
+                Err(e) => {
+                    println!("[bob] ERROR {:?}", e);
+                    if let ReceiveError::ByzantineFault { unnatural, .. } = e {
+                        assert!(!unnatural)
+                    }
+                }
+            }
+        }
+
+        let speed_metric_elapsed = current_time - last_speed_metric;
+        if speed_metric_elapsed >= 10000 {
+            last_speed_metric = current_time;
+            println!(
+                "[bob] throughput: {} MiB/sec (combined input and output)",
+                ((transferred as f64) / 1048576.0) / ((speed_metric_elapsed as f64) / 1000.0)
+            );
+            transferred = 0;
+        }
+
+        if current_time >= next_service {
+            next_service = current_time
+                + context.service(bob_app, |_| {
+                    Some((|b: &mut [u8]| bob_out.send(b.to_vec()).is_ok(), TEST_MTU))
+                });
+        }
+    }
+}
+
+fn core(time: u64) {
+    let run = &AtomicBool::new(true);
+
+    let alice_keypair = P384CrateKeyPair::generate(&mut OsRng);
+    let alice_app = TestApplication { time: Instant::now()};
+    let bob_keypair = P384CrateKeyPair::generate(&mut OsRng);
+    let bob_pubkey = bob_keypair.public_key();
+    let bob_app = TestApplication { time: Instant::now() };
+
+    let (alice_out, bob_in) = mpsc::sync_channel::<Vec<u8>>(256);
+    let (bob_out, alice_in) = mpsc::sync_channel::<Vec<u8>>(256);
+
+    thread::scope(|ts| {
+        {
+            let alice_out = alice_out.clone();
+            ts.spawn(move || {
+                alice_main(
+                    run,
+                    &alice_app,
+                    alice_out,
+                    alice_in,
+                    alice_keypair,
+                    bob_pubkey,
+                )
+            });
+        }
+        ts.spawn(move || bob_main(run, &bob_app, bob_out, bob_in, bob_keypair));
+
+        thread::sleep(Duration::from_secs(time));
+
+        run.store(false, Ordering::SeqCst);
+        println!("finished");
+    });
+}
+
+fn main() {
+    core(60 * 60)
+}
+
+#[test]
+fn test_main() {
+    core(2)
+}
diff --git a/src/application.rs b/src/application.rs
index fe94c9f..3246920 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -243,7 +243,8 @@ pub trait ApplicationLayer: Sized {
     /// These are provided for debugging, logging or metrics purposes, and must be used for
     /// nothing else. Do not base protocol-level decisions upon the events passed to this function.
     #[cfg(feature = "logging")]
-    fn event_log(&mut self, event: crate::LogEvent<'_, Self::Crypto>);
+    #[allow(unused)]
+    fn event_log(&mut self, event: crate::LogEvent<'_, Self::Crypto>) {}
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
diff --git a/src/zeta.rs b/src/zeta.rs
index 59abe4c..f6d3cb7 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -229,7 +229,7 @@ pub(crate) fn from_nonce(n: &[u8]) -> (u8, u64) {
     let c_start = n.len() - 8;
     (n[c_start - 1], u64::from_be_bytes(n[c_start..].try_into().unwrap()))
 }
-fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_NONCE_SIZE]) {
+pub(crate) fn set_header(packet: &mut [u8], kid_send: u32, nonce: &[u8; AES_GCM_NONCE_SIZE]) {
     packet[..KID_SIZE].copy_from_slice(&kid_send.to_ne_bytes());
     packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce[NONCE_SIZE_DIFF..]);
 }
diff --git a/src/zssp.rs b/src/zssp.rs
index 7190c3a..2996c0c 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -8,16 +8,16 @@ use std::sync::{Arc, Mutex, RwLock, Weak};
 use arrayvec::ArrayVec;
 use rand_core::RngCore;
 
+use crate::application::*;
 use crate::challenge::ChallengeContext;
 use crate::crypto::*;
-use crate::zeta::*;
-use crate::application::*;
 use crate::frag_cache::UnassociatedFragCache;
 use crate::fragged::Assembled;
 use crate::handshake_cache::UnassociatedHandshakeCache;
 use crate::indexed_heap::IndexedBinaryHeap;
 use crate::proto::*;
 use crate::result::{fault, FaultType, OpenError, ReceiveError, ReceiveOk, SendError, SessionEvent};
+use crate::zeta::*;
 #[cfg(feature = "logging")]
 use crate::LogEvent::*;
 
@@ -549,7 +549,8 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                             challenge_packet.extend(challenge);
                             let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
                             challenge_packet[FRAGMENT_COUNT_IDX] = 1;
-                            challenge_packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce);
+                            challenge_packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce[..PACKET_NONCE_SIZE]);
+                            set_header(&mut challenge_packet, 0, &nonce);
 
                             send_unassociated_reply(&mut challenge_packet);
                             // If we issue a challenge the first hello packet will always fail.

From ad8272bf4acb2b12458d9b88ed4dfaa36af13624 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 13:07:03 -0400
Subject: [PATCH 36/50] fixed benchmark

---
 examples/benchmark.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index 52ce563..0defb8d 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -107,6 +107,7 @@ fn alice_main(
     let mut next_service = startup_time.elapsed().as_millis() as i64 + 500;
     let test_data = [1u8; TEST_MTU * 10];
     let mut up = false;
+    let mut output_data = ArrayVec::<u8, 15000>::new();
 
     let alice_session = Some(
         context
@@ -128,7 +129,7 @@ fn alice_main(
             if let Ok(pkt) = pkt {
                 use zssp::result::ReceiveOk::*;
                 use zssp::result::SessionEvent::*;
-                let mut output_data = Vec::new();
+                output_data.clear();
                 match context.receive(
                     alice_app,
                     |b| alice_out.send(b.to_vec()).is_ok(),
@@ -210,6 +211,7 @@ fn bob_main(
         if let Ok(pkt) = pkt {
             use zssp::result::ReceiveOk::*;
             use zssp::result::SessionEvent::*;
+            output_data.clear();
             match context.receive(
                 bob_app,
                 |b| bob_out.send(b.to_vec()).is_ok(),

From 9f4cd4bfcddd7e0597459ae3d0861595349dfd9e Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 13:28:21 -0400
Subject: [PATCH 37/50] removed extra lines

---
 examples/benchmark.rs | 13 ++-----------
 src/zeta.rs           |  7 ++-----
 src/zssp.rs           |  3 ++-
 3 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index 0defb8d..b8b9e4e 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -275,7 +275,7 @@ fn core(time: u64) {
     let run = &AtomicBool::new(true);
 
     let alice_keypair = P384CrateKeyPair::generate(&mut OsRng);
-    let alice_app = TestApplication { time: Instant::now()};
+    let alice_app = TestApplication { time: Instant::now() };
     let bob_keypair = P384CrateKeyPair::generate(&mut OsRng);
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication { time: Instant::now() };
@@ -286,16 +286,7 @@ fn core(time: u64) {
     thread::scope(|ts| {
         {
             let alice_out = alice_out.clone();
-            ts.spawn(move || {
-                alice_main(
-                    run,
-                    &alice_app,
-                    alice_out,
-                    alice_in,
-                    alice_keypair,
-                    bob_pubkey,
-                )
-            });
+            ts.spawn(move || alice_main(run, &alice_app, alice_out, alice_in, alice_keypair, bob_pubkey));
         }
         ts.spawn(move || bob_main(run, &bob_app, bob_out, bob_in, bob_keypair));
 
diff --git a/src/zeta.rs b/src/zeta.rs
index f6d3cb7..b2d9b52 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -1705,11 +1705,8 @@ pub(crate) fn send_payload<Crypto: CryptoLayer>(
     );
     mtu_sized_buffer[HEADER_SIZE + payload_rem..HEADER_SIZE + fragment_len].copy_from_slice(&cipher.finish());
 
-    state.hk_send.encrypt_in_place(
-        (&mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END])
-            .try_into()
-            .unwrap(),
-    );
+    let header_auth = &mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END];
+    state.hk_send.encrypt_in_place(header_auth.try_into().unwrap());
 
     if !send(&mut mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
         return Ok(());
diff --git a/src/zssp.rs b/src/zssp.rs
index 2996c0c..27b24a6 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -549,7 +549,8 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                             challenge_packet.extend(challenge);
                             let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
                             challenge_packet[FRAGMENT_COUNT_IDX] = 1;
-                            challenge_packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce[..PACKET_NONCE_SIZE]);
+                            challenge_packet[PACKET_NONCE_START..HEADER_SIZE]
+                                .copy_from_slice(&nonce[..PACKET_NONCE_SIZE]);
                             set_header(&mut challenge_packet, 0, &nonce);
 
                             send_unassociated_reply(&mut challenge_packet);

From ea46c2bced38b7ccbaff987676b67536a66d2ba4 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 16:21:21 -0400
Subject: [PATCH 38/50] added profiler

---
 .gitignore            |   1 +
 Cargo.toml            |   3 +
 examples/benchmark.rs |  15 +-
 flamegraph.svg        | 491 ++++++++++++++++++++++++++++++++++++++++++
 src/zeta.rs           |  26 +--
 src/zssp.rs           |   3 +-
 6 files changed, 508 insertions(+), 31 deletions(-)
 create mode 100644 flamegraph.svg

diff --git a/.gitignore b/.gitignore
index ea8c4bf..790f4b6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 /target
+./perf*
diff --git a/Cargo.toml b/Cargo.toml
index 48a75dc..80513a0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,6 +10,9 @@ name = "zssp"
 path = "src/lib.rs"
 doc = true
 
+[profile.bench]
+debug = true
+
 [dependencies]
 rand_core = { version = "0.6.4" }
 zeroize = { version = "1.6.0" }
diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index 0defb8d..b2ec3fb 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -275,7 +275,7 @@ fn core(time: u64) {
     let run = &AtomicBool::new(true);
 
     let alice_keypair = P384CrateKeyPair::generate(&mut OsRng);
-    let alice_app = TestApplication { time: Instant::now()};
+    let alice_app = TestApplication { time: Instant::now() };
     let bob_keypair = P384CrateKeyPair::generate(&mut OsRng);
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication { time: Instant::now() };
@@ -286,16 +286,7 @@ fn core(time: u64) {
     thread::scope(|ts| {
         {
             let alice_out = alice_out.clone();
-            ts.spawn(move || {
-                alice_main(
-                    run,
-                    &alice_app,
-                    alice_out,
-                    alice_in,
-                    alice_keypair,
-                    bob_pubkey,
-                )
-            });
+            ts.spawn(move || alice_main(run, &alice_app, alice_out, alice_in, alice_keypair, bob_pubkey));
         }
         ts.spawn(move || bob_main(run, &bob_app, bob_out, bob_in, bob_keypair));
 
@@ -307,7 +298,7 @@ fn core(time: u64) {
 }
 
 fn main() {
-    core(60 * 60)
+    core(20)
 }
 
 #[test]
diff --git a/flamegraph.svg b/flamegraph.svg
new file mode 100644
index 0000000..8075ab4
--- /dev/null
+++ b/flamegraph.svg
@@ -0,0 +1,491 @@
+<?xml version="1.0" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg version="1.1" width="1200" height="598" onload="init(evt)" viewBox="0 0 1200 598" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:fg="http://github.com/jonhoo/inferno"><!--Flame graph stack visualization. See https://github.com/brendangregg/FlameGraph for latest version, and http://www.brendangregg.com/flamegraphs.html for examples.--><!--NOTES: --><defs><linearGradient id="background" y1="0" y2="1" x1="0" x2="0"><stop stop-color="#eeeeee" offset="5%"/><stop stop-color="#eeeeb0" offset="95%"/></linearGradient></defs><style type="text/css">
+text { font-family:monospace; font-size:12px }
+#title { text-anchor:middle; font-size:17px; }
+#matched { text-anchor:end; }
+#search { text-anchor:end; opacity:0.1; cursor:pointer; }
+#search:hover, #search.show { opacity:1; }
+#subtitle { text-anchor:middle; font-color:rgb(160,160,160); }
+#unzoom { cursor:pointer; }
+#frames > *:hover { stroke:black; stroke-width:0.5; cursor:pointer; }
+.hide { display:none; }
+.parent { opacity:0.5; }
+</style><script type="text/ecmascript"><![CDATA[
+        var nametype = 'Function:';
+        var fontsize = 12;
+        var fontwidth = 0.59;
+        var xpad = 10;
+        var inverted = false;
+        var searchcolor = 'rgb(230,0,230)';
+        var fluiddrawing = true;
+        var truncate_text_right = false;
+    ]]><![CDATA["use strict";
+var details, searchbtn, unzoombtn, matchedtxt, svg, searching, frames, known_font_width;
+function init(evt) {
+    details = document.getElementById("details").firstChild;
+    searchbtn = document.getElementById("search");
+    unzoombtn = document.getElementById("unzoom");
+    matchedtxt = document.getElementById("matched");
+    svg = document.getElementsByTagName("svg")[0];
+    frames = document.getElementById("frames");
+    known_font_width = get_monospace_width(frames);
+    total_samples = parseInt(frames.attributes.total_samples.value);
+    searching = 0;
+
+    // Use GET parameters to restore a flamegraph's state.
+    var restore_state = function() {
+        var params = get_params();
+        if (params.x && params.y)
+            zoom(find_group(document.querySelector('[*|x="' + params.x + '"][y="' + params.y + '"]')));
+        if (params.s)
+            search(params.s);
+    };
+
+    if (fluiddrawing) {
+        // Make width dynamic so the SVG fits its parent's width.
+        svg.removeAttribute("width");
+        // Edge requires us to have a viewBox that gets updated with size changes.
+        var isEdge = /Edge\/\d./i.test(navigator.userAgent);
+        if (!isEdge) {
+            svg.removeAttribute("viewBox");
+        }
+        var update_for_width_change = function() {
+            if (isEdge) {
+                svg.attributes.viewBox.value = "0 0 " + svg.width.baseVal.value + " " + svg.height.baseVal.value;
+            }
+
+            // Keep consistent padding on left and right of frames container.
+            frames.attributes.width.value = svg.width.baseVal.value - xpad * 2;
+
+            // Text truncation needs to be adjusted for the current width.
+            update_text_for_elements(frames.children);
+
+            // Keep search elements at a fixed distance from right edge.
+            var svgWidth = svg.width.baseVal.value;
+            searchbtn.attributes.x.value = svgWidth - xpad;
+            matchedtxt.attributes.x.value = svgWidth - xpad;
+        };
+        window.addEventListener('resize', function() {
+            update_for_width_change();
+        });
+        // This needs to be done asynchronously for Safari to work.
+        setTimeout(function() {
+            unzoom();
+            update_for_width_change();
+            restore_state();
+        }, 0);
+    } else {
+        restore_state();
+    }
+}
+// event listeners
+window.addEventListener("click", function(e) {
+    var target = find_group(e.target);
+    if (target) {
+        if (target.nodeName == "a") {
+            if (e.ctrlKey === false) return;
+            e.preventDefault();
+        }
+        if (target.classList.contains("parent")) unzoom();
+        zoom(target);
+
+        // set parameters for zoom state
+        var el = target.querySelector("rect");
+        if (el && el.attributes && el.attributes.y && el.attributes["fg:x"]) {
+            var params = get_params()
+            params.x = el.attributes["fg:x"].value;
+            params.y = el.attributes.y.value;
+            history.replaceState(null, null, parse_params(params));
+        }
+    }
+    else if (e.target.id == "unzoom") {
+        unzoom();
+
+        // remove zoom state
+        var params = get_params();
+        if (params.x) delete params.x;
+        if (params.y) delete params.y;
+        history.replaceState(null, null, parse_params(params));
+    }
+    else if (e.target.id == "search") search_prompt();
+}, false)
+// mouse-over for info
+// show
+window.addEventListener("mouseover", function(e) {
+    var target = find_group(e.target);
+    if (target) details.nodeValue = nametype + " " + g_to_text(target);
+}, false)
+// clear
+window.addEventListener("mouseout", function(e) {
+    var target = find_group(e.target);
+    if (target) details.nodeValue = ' ';
+}, false)
+// ctrl-F for search
+window.addEventListener("keydown",function (e) {
+    if (e.keyCode === 114 || (e.ctrlKey && e.keyCode === 70)) {
+        e.preventDefault();
+        search_prompt();
+    }
+}, false)
+// functions
+function get_params() {
+    var params = {};
+    var paramsarr = window.location.search.substr(1).split('&');
+    for (var i = 0; i < paramsarr.length; ++i) {
+        var tmp = paramsarr[i].split("=");
+        if (!tmp[0] || !tmp[1]) continue;
+        params[tmp[0]]  = decodeURIComponent(tmp[1]);
+    }
+    return params;
+}
+function parse_params(params) {
+    var uri = "?";
+    for (var key in params) {
+        uri += key + '=' + encodeURIComponent(params[key]) + '&';
+    }
+    if (uri.slice(-1) == "&")
+        uri = uri.substring(0, uri.length - 1);
+    if (uri == '?')
+        uri = window.location.href.split('?')[0];
+    return uri;
+}
+function find_child(node, selector) {
+    var children = node.querySelectorAll(selector);
+    if (children.length) return children[0];
+    return;
+}
+function find_group(node) {
+    var parent = node.parentElement;
+    if (!parent) return;
+    if (parent.id == "frames") return node;
+    return find_group(parent);
+}
+function orig_save(e, attr, val) {
+    if (e.attributes["fg:orig_" + attr] != undefined) return;
+    if (e.attributes[attr] == undefined) return;
+    if (val == undefined) val = e.attributes[attr].value;
+    e.setAttribute("fg:orig_" + attr, val);
+}
+function orig_load(e, attr) {
+    if (e.attributes["fg:orig_"+attr] == undefined) return;
+    e.attributes[attr].value = e.attributes["fg:orig_" + attr].value;
+    e.removeAttribute("fg:orig_" + attr);
+}
+function g_to_text(e) {
+    var text = find_child(e, "title").firstChild.nodeValue;
+    return (text)
+}
+function g_to_func(e) {
+    var func = g_to_text(e);
+    // if there's any manipulation we want to do to the function
+    // name before it's searched, do it here before returning.
+    return (func);
+}
+function get_monospace_width(frames) {
+    // Given the id="frames" element, return the width of text characters if
+    // this is a monospace font, otherwise return 0.
+    text = find_child(frames.children[0], "text");
+    originalContent = text.textContent;
+    text.textContent = "!";
+    bangWidth = text.getComputedTextLength();
+    text.textContent = "W";
+    wWidth = text.getComputedTextLength();
+    text.textContent = originalContent;
+    if (bangWidth === wWidth) {
+        return bangWidth;
+    } else {
+        return 0;
+    }
+}
+function update_text_for_elements(elements) {
+    // In order to render quickly in the browser, you want to do one pass of
+    // reading attributes, and one pass of mutating attributes. See
+    // https://web.dev/avoid-large-complex-layouts-and-layout-thrashing/ for details.
+
+    // Fall back to inefficient calculation, if we're variable-width font.
+    // TODO This should be optimized somehow too.
+    if (known_font_width === 0) {
+        for (var i = 0; i < elements.length; i++) {
+            update_text(elements[i]);
+        }
+        return;
+    }
+
+    var textElemNewAttributes = [];
+    for (var i = 0; i < elements.length; i++) {
+        var e = elements[i];
+        var r = find_child(e, "rect");
+        var t = find_child(e, "text");
+        var w = parseFloat(r.attributes.width.value) * frames.attributes.width.value / 100 - 3;
+        var txt = find_child(e, "title").textContent.replace(/\([^(]*\)$/,"");
+        var newX = format_percent((parseFloat(r.attributes.x.value) + (100 * 3 / frames.attributes.width.value)));
+
+        // Smaller than this size won't fit anything
+        if (w < 2 * known_font_width) {
+            textElemNewAttributes.push([newX, ""]);
+            continue;
+        }
+
+        // Fit in full text width
+        if (txt.length * known_font_width < w) {
+            textElemNewAttributes.push([newX, txt]);
+            continue;
+        }
+
+        var substringLength = Math.floor(w / known_font_width) - 2;
+        if (truncate_text_right) {
+            // Truncate the right side of the text.
+            textElemNewAttributes.push([newX, txt.substring(0, substringLength) + ".."]);
+            continue;
+        } else {
+            // Truncate the left side of the text.
+            textElemNewAttributes.push([newX, ".." + txt.substring(txt.length - substringLength, txt.length)]);
+            continue;
+        }
+    }
+
+    console.assert(textElemNewAttributes.length === elements.length, "Resize failed, please file a bug at https://github.com/jonhoo/inferno/");
+
+    // Now that we know new textContent, set it all in one go so we don't refresh a bazillion times.
+    for (var i = 0; i < elements.length; i++) {
+        var e = elements[i];
+        var values = textElemNewAttributes[i];
+        var t = find_child(e, "text");
+        t.attributes.x.value = values[0];
+        t.textContent = values[1];
+    }
+}
+
+function update_text(e) {
+    var r = find_child(e, "rect");
+    var t = find_child(e, "text");
+    var w = parseFloat(r.attributes.width.value) * frames.attributes.width.value / 100 - 3;
+    var txt = find_child(e, "title").textContent.replace(/\([^(]*\)$/,"");
+    t.attributes.x.value = format_percent((parseFloat(r.attributes.x.value) + (100 * 3 / frames.attributes.width.value)));
+
+    // Smaller than this size won't fit anything
+    if (w < 2 * fontsize * fontwidth) {
+        t.textContent = "";
+        return;
+    }
+    t.textContent = txt;
+    // Fit in full text width
+    if (t.getComputedTextLength() < w)
+        return;
+    if (truncate_text_right) {
+        // Truncate the right side of the text.
+        for (var x = txt.length - 2; x > 0; x--) {
+            if (t.getSubStringLength(0, x + 2) <= w) {
+                t.textContent = txt.substring(0, x) + "..";
+                return;
+            }
+        }
+    } else {
+        // Truncate the left side of the text.
+        for (var x = 2; x < txt.length; x++) {
+            if (t.getSubStringLength(x - 2, txt.length) <= w) {
+                t.textContent = ".." + txt.substring(x, txt.length);
+                return;
+            }
+        }
+    }
+    t.textContent = "";
+}
+// zoom
+function zoom_reset(e) {
+    if (e.tagName == "rect") {
+        e.attributes.x.value = format_percent(100 * parseInt(e.attributes["fg:x"].value) / total_samples);
+        e.attributes.width.value = format_percent(100 * parseInt(e.attributes["fg:w"].value) / total_samples);
+    }
+    if (e.childNodes == undefined) return;
+    for(var i = 0, c = e.childNodes; i < c.length; i++) {
+        zoom_reset(c[i]);
+    }
+}
+function zoom_child(e, x, zoomed_width_samples) {
+    if (e.tagName == "text") {
+        var parent_x = parseFloat(find_child(e.parentNode, "rect[x]").attributes.x.value);
+        e.attributes.x.value = format_percent(parent_x + (100 * 3 / frames.attributes.width.value));
+    } else if (e.tagName == "rect") {
+        e.attributes.x.value = format_percent(100 * (parseInt(e.attributes["fg:x"].value) - x) / zoomed_width_samples);
+        e.attributes.width.value = format_percent(100 * parseInt(e.attributes["fg:w"].value) / zoomed_width_samples);
+    }
+    if (e.childNodes == undefined) return;
+    for(var i = 0, c = e.childNodes; i < c.length; i++) {
+        zoom_child(c[i], x, zoomed_width_samples);
+    }
+}
+function zoom_parent(e) {
+    if (e.attributes) {
+        if (e.attributes.x != undefined) {
+            e.attributes.x.value = "0.0%";
+        }
+        if (e.attributes.width != undefined) {
+            e.attributes.width.value = "100.0%";
+        }
+    }
+    if (e.childNodes == undefined) return;
+    for(var i = 0, c = e.childNodes; i < c.length; i++) {
+        zoom_parent(c[i]);
+    }
+}
+function zoom(node) {
+    var attr = find_child(node, "rect").attributes;
+    var width = parseInt(attr["fg:w"].value);
+    var xmin = parseInt(attr["fg:x"].value);
+    var xmax = xmin + width;
+    var ymin = parseFloat(attr.y.value);
+    unzoombtn.classList.remove("hide");
+    var el = frames.children;
+    var to_update_text = [];
+    for (var i = 0; i < el.length; i++) {
+        var e = el[i];
+        var a = find_child(e, "rect").attributes;
+        var ex = parseInt(a["fg:x"].value);
+        var ew = parseInt(a["fg:w"].value);
+        // Is it an ancestor
+        if (!inverted) {
+            var upstack = parseFloat(a.y.value) > ymin;
+        } else {
+            var upstack = parseFloat(a.y.value) < ymin;
+        }
+        if (upstack) {
+            // Direct ancestor
+            if (ex <= xmin && (ex+ew) >= xmax) {
+                e.classList.add("parent");
+                zoom_parent(e);
+                to_update_text.push(e);
+            }
+            // not in current path
+            else
+                e.classList.add("hide");
+        }
+        // Children maybe
+        else {
+            // no common path
+            if (ex < xmin || ex >= xmax) {
+                e.classList.add("hide");
+            }
+            else {
+                zoom_child(e, xmin, width);
+                to_update_text.push(e);
+            }
+        }
+    }
+    update_text_for_elements(to_update_text);
+}
+function unzoom() {
+    unzoombtn.classList.add("hide");
+    var el = frames.children;
+    for(var i = 0; i < el.length; i++) {
+        el[i].classList.remove("parent");
+        el[i].classList.remove("hide");
+        zoom_reset(el[i]);
+    }
+    update_text_for_elements(el);
+}
+// search
+function reset_search() {
+    var el = document.querySelectorAll("#frames rect");
+    for (var i = 0; i < el.length; i++) {
+        orig_load(el[i], "fill")
+    }
+    var params = get_params();
+    delete params.s;
+    history.replaceState(null, null, parse_params(params));
+}
+function search_prompt() {
+    if (!searching) {
+        var term = prompt("Enter a search term (regexp " +
+            "allowed, eg: ^ext4_)", "");
+        if (term != null) {
+            search(term)
+        }
+    } else {
+        reset_search();
+        searching = 0;
+        searchbtn.classList.remove("show");
+        searchbtn.firstChild.nodeValue = "Search"
+        matchedtxt.classList.add("hide");
+        matchedtxt.firstChild.nodeValue = ""
+    }
+}
+function search(term) {
+    var re = new RegExp(term);
+    var el = frames.children;
+    var matches = new Object();
+    var maxwidth = 0;
+    for (var i = 0; i < el.length; i++) {
+        var e = el[i];
+        // Skip over frames which are either not visible, or below the zoomed-to frame
+        if (e.classList.contains("hide") || e.classList.contains("parent")) {
+            continue;
+        }
+        var func = g_to_func(e);
+        var rect = find_child(e, "rect");
+        if (func == null || rect == null)
+            continue;
+        // Save max width. Only works as we have a root frame
+        var w = parseInt(rect.attributes["fg:w"].value);
+        if (w > maxwidth)
+            maxwidth = w;
+        if (func.match(re)) {
+            // highlight
+            var x = parseInt(rect.attributes["fg:x"].value);
+            orig_save(rect, "fill");
+            rect.attributes.fill.value = searchcolor;
+            // remember matches
+            if (matches[x] == undefined) {
+                matches[x] = w;
+            } else {
+                if (w > matches[x]) {
+                    // overwrite with parent
+                    matches[x] = w;
+                }
+            }
+            searching = 1;
+        }
+    }
+    if (!searching)
+        return;
+    var params = get_params();
+    params.s = term;
+    history.replaceState(null, null, parse_params(params));
+
+    searchbtn.classList.add("show");
+    searchbtn.firstChild.nodeValue = "Reset Search";
+    // calculate percent matched, excluding vertical overlap
+    var count = 0;
+    var lastx = -1;
+    var lastw = 0;
+    var keys = Array();
+    for (k in matches) {
+        if (matches.hasOwnProperty(k))
+            keys.push(k);
+    }
+    // sort the matched frames by their x location
+    // ascending, then width descending
+    keys.sort(function(a, b){
+        return a - b;
+    });
+    // Step through frames saving only the biggest bottom-up frames
+    // thanks to the sort order. This relies on the tree property
+    // where children are always smaller than their parents.
+    for (var k in keys) {
+        var x = parseInt(keys[k]);
+        var w = matches[keys[k]];
+        if (x >= lastx + lastw) {
+            count += w;
+            lastx = x;
+            lastw = w;
+        }
+    }
+    // display matched percent
+    matchedtxt.classList.remove("hide");
+    var pct = 100 * count / maxwidth;
+    if (pct != 100) pct = pct.toFixed(1);
+    matchedtxt.firstChild.nodeValue = "Matched: " + pct + "%";
+}
+function format_percent(n) {
+    return n.toFixed(4) + "%";
+}
+]]></script><rect x="0" y="0" width="100%" height="598" fill="url(#background)"/><text id="title" fill="rgb(0,0,0)" x="50.0000%" y="24.00">Flame Graph</text><text id="details" fill="rgb(0,0,0)" x="10" y="581.00"> </text><text id="unzoom" class="hide" fill="rgb(0,0,0)" x="10" y="24.00">Reset Zoom</text><text id="search" fill="rgb(0,0,0)" x="1190" y="24.00">Search</text><text id="matched" fill="rgb(0,0,0)" x="1190" y="581.00"> </text><svg id="frames" x="10" width="1180" total_samples="39082"><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (13 samples, 0.03%)</title><rect x="0.0179%" y="501" width="0.0333%" height="15" fill="rgb(227,0,7)" fg:x="7" fg:w="13"/><text x="0.2679%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (5 samples, 0.01%)</title><rect x="0.0384%" y="485" width="0.0128%" height="15" fill="rgb(217,0,24)" fg:x="15" fg:w="5"/><text x="0.2884%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (35 samples, 0.09%)</title><rect x="0.0512%" y="501" width="0.0896%" height="15" fill="rgb(221,193,54)" fg:x="20" fg:w="35"/><text x="0.3012%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (5 samples, 0.01%)</title><rect x="0.1279%" y="485" width="0.0128%" height="15" fill="rgb(248,212,6)" fg:x="50" fg:w="5"/><text x="0.3779%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (71 samples, 0.18%)</title><rect x="0.1407%" y="501" width="0.1817%" height="15" fill="rgb(208,68,35)" fg:x="55" fg:w="71"/><text x="0.3907%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (8 samples, 0.02%)</title><rect x="0.3301%" y="501" width="0.0205%" height="15" fill="rgb(232,128,0)" fg:x="129" fg:w="8"/><text x="0.5801%" y="511.50"></text></g><g><title>CRYPTO_THREAD_read_lock (7 samples, 0.02%)</title><rect x="0.3505%" y="501" width="0.0179%" height="15" fill="rgb(207,160,47)" fg:x="137" fg:w="7"/><text x="0.6005%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt (8 samples, 0.02%)</title><rect x="0.3736%" y="501" width="0.0205%" height="15" fill="rgb(228,23,34)" fg:x="146" fg:w="8"/><text x="0.6236%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (21 samples, 0.05%)</title><rect x="0.3940%" y="501" width="0.0537%" height="15" fill="rgb(218,30,26)" fg:x="154" fg:w="21"/><text x="0.6440%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt (10 samples, 0.03%)</title><rect x="0.4478%" y="501" width="0.0256%" height="15" fill="rgb(220,122,19)" fg:x="175" fg:w="10"/><text x="0.6978%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (16 samples, 0.04%)</title><rect x="0.4734%" y="501" width="0.0409%" height="15" fill="rgb(250,228,42)" fg:x="185" fg:w="16"/><text x="0.7234%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (4 samples, 0.01%)</title><rect x="0.5143%" y="501" width="0.0102%" height="15" fill="rgb(240,193,28)" fg:x="201" fg:w="4"/><text x="0.7643%" y="511.50"></text></g><g><title>CRYPTO_gcm128_init (9 samples, 0.02%)</title><rect x="0.5245%" y="501" width="0.0230%" height="15" fill="rgb(216,20,37)" fg:x="205" fg:w="9"/><text x="0.7745%" y="511.50"></text></g><g><title>CRYPTO_gcm128_tag (5 samples, 0.01%)</title><rect x="0.5501%" y="501" width="0.0128%" height="15" fill="rgb(206,188,39)" fg:x="215" fg:w="5"/><text x="0.8001%" y="511.50"></text></g><g><title>CRYPTO_zalloc (25 samples, 0.06%)</title><rect x="0.5629%" y="501" width="0.0640%" height="15" fill="rgb(217,207,13)" fg:x="220" fg:w="25"/><text x="0.8129%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (5 samples, 0.01%)</title><rect x="0.6269%" y="501" width="0.0128%" height="15" fill="rgb(231,73,38)" fg:x="245" fg:w="5"/><text x="0.8769%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_reset (7 samples, 0.02%)</title><rect x="0.6474%" y="501" width="0.0179%" height="15" fill="rgb(225,20,46)" fg:x="253" fg:w="7"/><text x="0.8974%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (12 samples, 0.03%)</title><rect x="0.6653%" y="501" width="0.0307%" height="15" fill="rgb(210,31,41)" fg:x="260" fg:w="12"/><text x="0.9153%" y="511.50"></text></g><g><title>EVP_CIPHER_fetch (6 samples, 0.02%)</title><rect x="0.6960%" y="501" width="0.0154%" height="15" fill="rgb(221,200,47)" fg:x="272" fg:w="6"/><text x="0.9460%" y="511.50"></text></g><g><title>EVP_CIPHER_free (17 samples, 0.04%)</title><rect x="0.7113%" y="501" width="0.0435%" height="15" fill="rgb(226,26,5)" fg:x="278" fg:w="17"/><text x="0.9613%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (4 samples, 0.01%)</title><rect x="0.7702%" y="501" width="0.0102%" height="15" fill="rgb(249,33,26)" fg:x="301" fg:w="4"/><text x="1.0202%" y="511.50"></text></g><g><title>EVP_EncryptFinal_ex (6 samples, 0.02%)</title><rect x="0.7804%" y="501" width="0.0154%" height="15" fill="rgb(235,183,28)" fg:x="305" fg:w="6"/><text x="1.0304%" y="511.50"></text></g><g><title>OPENSSL_LH_retrieve (10 samples, 0.03%)</title><rect x="0.8137%" y="501" width="0.0256%" height="15" fill="rgb(221,5,38)" fg:x="318" fg:w="10"/><text x="1.0637%" y="511.50"></text></g><g><title>OPENSSL_strnlen (5 samples, 0.01%)</title><rect x="0.8469%" y="501" width="0.0128%" height="15" fill="rgb(247,18,42)" fg:x="331" fg:w="5"/><text x="1.0969%" y="511.50"></text></g><g><title>OSSL_PARAM_locate (121 samples, 0.31%)</title><rect x="0.8623%" y="501" width="0.3096%" height="15" fill="rgb(241,131,45)" fg:x="337" fg:w="121"/><text x="1.1123%" y="511.50"></text></g><g><title>OSSL_PARAM_set_uint64 (4 samples, 0.01%)</title><rect x="1.1745%" y="501" width="0.0102%" height="15" fill="rgb(249,31,29)" fg:x="459" fg:w="4"/><text x="1.4245%" y="511.50"></text></g><g><title>[libc.so.6] (60 samples, 0.15%)</title><rect x="1.1898%" y="501" width="0.1535%" height="15" fill="rgb(225,111,53)" fg:x="465" fg:w="60"/><text x="1.4398%" y="511.50"></text></g><g><title>[libcrypto.so.3] (289 samples, 0.74%)</title><rect x="1.3433%" y="501" width="0.7395%" height="15" fill="rgb(238,160,17)" fg:x="525" fg:w="289"/><text x="1.5933%" y="511.50"></text></g><g><title>cfree (13 samples, 0.03%)</title><rect x="2.0905%" y="501" width="0.0333%" height="15" fill="rgb(214,148,48)" fg:x="817" fg:w="13"/><text x="2.3405%" y="511.50"></text></g><g><title>malloc (31 samples, 0.08%)</title><rect x="2.1340%" y="501" width="0.0793%" height="15" fill="rgb(232,36,49)" fg:x="834" fg:w="31"/><text x="2.3840%" y="511.50"></text></g><g><title>pthread_rwlock_rdlock (5 samples, 0.01%)</title><rect x="2.2159%" y="501" width="0.0128%" height="15" fill="rgb(209,103,24)" fg:x="866" fg:w="5"/><text x="2.4659%" y="511.50"></text></g><g><title>pthread_rwlock_unlock (7 samples, 0.02%)</title><rect x="2.2286%" y="501" width="0.0179%" height="15" fill="rgb(229,88,8)" fg:x="871" fg:w="7"/><text x="2.4786%" y="511.50"></text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (9 samples, 0.02%)</title><rect x="2.2542%" y="501" width="0.0230%" height="15" fill="rgb(213,181,19)" fg:x="881" fg:w="9"/><text x="2.5042%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (11 samples, 0.03%)</title><rect x="2.3233%" y="485" width="0.0281%" height="15" fill="rgb(254,191,54)" fg:x="908" fg:w="11"/><text x="2.5733%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (11 samples, 0.03%)</title><rect x="2.3515%" y="485" width="0.0281%" height="15" fill="rgb(241,83,37)" fg:x="919" fg:w="11"/><text x="2.6015%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (45 samples, 0.12%)</title><rect x="2.2824%" y="501" width="0.1151%" height="15" fill="rgb(233,36,39)" fg:x="892" fg:w="45"/><text x="2.5324%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (7 samples, 0.02%)</title><rect x="2.3796%" y="485" width="0.0179%" height="15" fill="rgb(226,3,54)" fg:x="930" fg:w="7"/><text x="2.6296%" y="495.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (5 samples, 0.01%)</title><rect x="2.4333%" y="485" width="0.0128%" height="15" fill="rgb(245,192,40)" fg:x="951" fg:w="5"/><text x="2.6833%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::try_recv (19 samples, 0.05%)</title><rect x="2.4026%" y="501" width="0.0486%" height="15" fill="rgb(238,167,29)" fg:x="939" fg:w="19"/><text x="2.6526%" y="511.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (11 samples, 0.03%)</title><rect x="2.4513%" y="501" width="0.0281%" height="15" fill="rgb(232,182,51)" fg:x="958" fg:w="11"/><text x="2.7013%" y="511.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (10 samples, 0.03%)</title><rect x="2.4794%" y="485" width="0.0256%" height="15" fill="rgb(231,60,39)" fg:x="969" fg:w="10"/><text x="2.7294%" y="495.50"></text></g><g><title>core::sync::atomic::atomic_load (10 samples, 0.03%)</title><rect x="2.4794%" y="469" width="0.0256%" height="15" fill="rgb(208,69,12)" fg:x="969" fg:w="10"/><text x="2.7294%" y="479.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (11 samples, 0.03%)</title><rect x="2.4794%" y="501" width="0.0281%" height="15" fill="rgb(235,93,37)" fg:x="969" fg:w="11"/><text x="2.7294%" y="511.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (7 samples, 0.02%)</title><rect x="2.5075%" y="501" width="0.0179%" height="15" fill="rgb(213,116,39)" fg:x="980" fg:w="7"/><text x="2.7575%" y="511.50"></text></g><g><title>std::time::Instant::elapsed (7 samples, 0.02%)</title><rect x="2.5255%" y="501" width="0.0179%" height="15" fill="rgb(222,207,29)" fg:x="987" fg:w="7"/><text x="2.7755%" y="511.50"></text></g><g><title>syscall (10 samples, 0.03%)</title><rect x="2.5434%" y="501" width="0.0256%" height="15" fill="rgb(206,96,30)" fg:x="994" fg:w="10"/><text x="2.7934%" y="511.50"></text></g><g><title>__entry_text_start (6 samples, 0.02%)</title><rect x="2.5536%" y="485" width="0.0154%" height="15" fill="rgb(218,138,4)" fg:x="998" fg:w="6"/><text x="2.8036%" y="495.50"></text></g><g><title>[anon] (1,024 samples, 2.62%)</title><rect x="0.0154%" y="517" width="2.6201%" height="15" fill="rgb(250,191,14)" fg:x="6" fg:w="1024"/><text x="0.2654%" y="527.50">[a..</text></g><g><title>zssp::zeta::receive_payload_in_place (25 samples, 0.06%)</title><rect x="2.5715%" y="501" width="0.0640%" height="15" fill="rgb(239,60,40)" fg:x="1005" fg:w="25"/><text x="2.8215%" y="511.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (7 samples, 0.02%)</title><rect x="2.6176%" y="485" width="0.0179%" height="15" fill="rgb(206,27,48)" fg:x="1023" fg:w="7"/><text x="2.8676%" y="495.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (7 samples, 0.02%)</title><rect x="2.6176%" y="469" width="0.0179%" height="15" fill="rgb(225,35,8)" fg:x="1023" fg:w="7"/><text x="2.8676%" y="479.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (7 samples, 0.02%)</title><rect x="2.6176%" y="453" width="0.0179%" height="15" fill="rgb(250,213,24)" fg:x="1023" fg:w="7"/><text x="2.8676%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (7 samples, 0.02%)</title><rect x="2.6176%" y="437" width="0.0179%" height="15" fill="rgb(247,123,22)" fg:x="1023" fg:w="7"/><text x="2.8676%" y="447.50"></text></g><g><title>&lt;std::sync::mpmc::zero::ZeroToken as core::default::Default&gt;::default (4 samples, 0.01%)</title><rect x="2.6355%" y="501" width="0.0102%" height="15" fill="rgb(231,138,38)" fg:x="1030" fg:w="4"/><text x="2.8855%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (4 samples, 0.01%)</title><rect x="2.6457%" y="501" width="0.0102%" height="15" fill="rgb(231,145,46)" fg:x="1034" fg:w="4"/><text x="2.8957%" y="511.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="2.6560%" y="501" width="0.0128%" height="15" fill="rgb(251,118,11)" fg:x="1038" fg:w="5"/><text x="2.9060%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (8 samples, 0.02%)</title><rect x="2.6764%" y="501" width="0.0205%" height="15" fill="rgb(217,147,25)" fg:x="1046" fg:w="8"/><text x="2.9264%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (9 samples, 0.02%)</title><rect x="2.6969%" y="501" width="0.0230%" height="15" fill="rgb(247,81,37)" fg:x="1054" fg:w="9"/><text x="2.9469%" y="511.50"></text></g><g><title>[benchmark] (54 samples, 0.14%)</title><rect x="2.6355%" y="517" width="0.1382%" height="15" fill="rgb(209,12,38)" fg:x="1030" fg:w="54"/><text x="2.8855%" y="527.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (17 samples, 0.04%)</title><rect x="2.7302%" y="501" width="0.0435%" height="15" fill="rgb(227,1,9)" fg:x="1067" fg:w="17"/><text x="2.9802%" y="511.50"></text></g><g><title>CRYPTO_THREAD_read_lock (17 samples, 0.04%)</title><rect x="2.8120%" y="501" width="0.0435%" height="15" fill="rgb(248,47,43)" fg:x="1099" fg:w="17"/><text x="3.0620%" y="511.50"></text></g><g><title>CRYPTO_THREAD_run_once (4 samples, 0.01%)</title><rect x="2.8555%" y="501" width="0.0102%" height="15" fill="rgb(221,10,30)" fg:x="1116" fg:w="4"/><text x="3.1055%" y="511.50"></text></g><g><title>CRYPTO_THREAD_unlock (19 samples, 0.05%)</title><rect x="2.8658%" y="501" width="0.0486%" height="15" fill="rgb(210,229,1)" fg:x="1120" fg:w="19"/><text x="3.1158%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (14 samples, 0.04%)</title><rect x="2.9144%" y="501" width="0.0358%" height="15" fill="rgb(222,148,37)" fg:x="1139" fg:w="14"/><text x="3.1644%" y="511.50"></text></g><g><title>CRYPTO_gcm128_setiv (7 samples, 0.02%)</title><rect x="2.9502%" y="501" width="0.0179%" height="15" fill="rgb(234,67,33)" fg:x="1153" fg:w="7"/><text x="3.2002%" y="511.50"></text></g><g><title>CRYPTO_get_ex_data (10 samples, 0.03%)</title><rect x="2.9681%" y="501" width="0.0256%" height="15" fill="rgb(247,98,35)" fg:x="1160" fg:w="10"/><text x="3.2181%" y="511.50"></text></g><g><title>OPENSSL_sk_value (4 samples, 0.01%)</title><rect x="3.0065%" y="501" width="0.0102%" height="15" fill="rgb(247,138,52)" fg:x="1175" fg:w="4"/><text x="3.2565%" y="511.50"></text></g><g><title>OSSL_PARAM_construct_size_t (5 samples, 0.01%)</title><rect x="3.0193%" y="501" width="0.0128%" height="15" fill="rgb(213,79,30)" fg:x="1180" fg:w="5"/><text x="3.2693%" y="511.50"></text></g><g><title>[libc.so.6] (17 samples, 0.04%)</title><rect x="3.0346%" y="501" width="0.0435%" height="15" fill="rgb(246,177,23)" fg:x="1186" fg:w="17"/><text x="3.2846%" y="511.50"></text></g><g><title>[libcrypto.so.3] (145 samples, 0.37%)</title><rect x="3.0781%" y="501" width="0.3710%" height="15" fill="rgb(230,62,27)" fg:x="1203" fg:w="145"/><text x="3.3281%" y="511.50"></text></g><g><title>pthread_getspecific (7 samples, 0.02%)</title><rect x="3.4568%" y="501" width="0.0179%" height="15" fill="rgb(216,154,8)" fg:x="1351" fg:w="7"/><text x="3.7068%" y="511.50"></text></g><g><title>pthread_rwlock_rdlock (22 samples, 0.06%)</title><rect x="3.4747%" y="501" width="0.0563%" height="15" fill="rgb(244,35,45)" fg:x="1358" fg:w="22"/><text x="3.7247%" y="511.50"></text></g><g><title>[libcrypto.so.3] (316 samples, 0.81%)</title><rect x="2.7788%" y="517" width="0.8086%" height="15" fill="rgb(251,115,12)" fg:x="1086" fg:w="316"/><text x="3.0288%" y="527.50"></text></g><g><title>pthread_rwlock_unlock (22 samples, 0.06%)</title><rect x="3.5310%" y="501" width="0.0563%" height="15" fill="rgb(240,54,50)" fg:x="1380" fg:w="22"/><text x="3.7810%" y="511.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (14 samples, 0.04%)</title><rect x="3.5873%" y="501" width="0.0358%" height="15" fill="rgb(233,84,52)" fg:x="1402" fg:w="14"/><text x="3.8373%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (14 samples, 0.04%)</title><rect x="3.6334%" y="501" width="0.0358%" height="15" fill="rgb(207,117,47)" fg:x="1420" fg:w="14"/><text x="3.8834%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (4 samples, 0.01%)</title><rect x="3.6692%" y="501" width="0.0102%" height="15" fill="rgb(249,43,39)" fg:x="1434" fg:w="4"/><text x="3.9192%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (80 samples, 0.20%)</title><rect x="3.6794%" y="501" width="0.2047%" height="15" fill="rgb(209,38,44)" fg:x="1438" fg:w="80"/><text x="3.9294%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (10 samples, 0.03%)</title><rect x="3.8586%" y="485" width="0.0256%" height="15" fill="rgb(236,212,23)" fg:x="1508" fg:w="10"/><text x="4.1086%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (5 samples, 0.01%)</title><rect x="3.8841%" y="501" width="0.0128%" height="15" fill="rgb(242,79,21)" fg:x="1518" fg:w="5"/><text x="4.1341%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (8 samples, 0.02%)</title><rect x="3.8969%" y="501" width="0.0205%" height="15" fill="rgb(211,96,35)" fg:x="1523" fg:w="8"/><text x="4.1469%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (8 samples, 0.02%)</title><rect x="3.8969%" y="485" width="0.0205%" height="15" fill="rgb(253,215,40)" fg:x="1523" fg:w="8"/><text x="4.1469%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (7 samples, 0.02%)</title><rect x="3.9174%" y="501" width="0.0179%" height="15" fill="rgb(211,81,21)" fg:x="1531" fg:w="7"/><text x="4.1674%" y="511.50"></text></g><g><title>CRYPTO_THREAD_read_lock (6 samples, 0.02%)</title><rect x="3.9353%" y="501" width="0.0154%" height="15" fill="rgb(208,190,38)" fg:x="1538" fg:w="6"/><text x="4.1853%" y="511.50"></text></g><g><title>CRYPTO_THREAD_unlock (11 samples, 0.03%)</title><rect x="3.9532%" y="501" width="0.0281%" height="15" fill="rgb(235,213,38)" fg:x="1545" fg:w="11"/><text x="4.2032%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt (10 samples, 0.03%)</title><rect x="3.9890%" y="501" width="0.0256%" height="15" fill="rgb(237,122,38)" fg:x="1559" fg:w="10"/><text x="4.2390%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (22 samples, 0.06%)</title><rect x="4.0146%" y="501" width="0.0563%" height="15" fill="rgb(244,218,35)" fg:x="1569" fg:w="22"/><text x="4.2646%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt (15 samples, 0.04%)</title><rect x="4.0709%" y="501" width="0.0384%" height="15" fill="rgb(240,68,47)" fg:x="1591" fg:w="15"/><text x="4.3209%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (28 samples, 0.07%)</title><rect x="4.1093%" y="501" width="0.0716%" height="15" fill="rgb(210,16,53)" fg:x="1606" fg:w="28"/><text x="4.3593%" y="511.50"></text></g><g><title>CRYPTO_strndup (5 samples, 0.01%)</title><rect x="4.1912%" y="501" width="0.0128%" height="15" fill="rgb(235,124,12)" fg:x="1638" fg:w="5"/><text x="4.4412%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (10 samples, 0.03%)</title><rect x="4.2040%" y="501" width="0.0256%" height="15" fill="rgb(224,169,11)" fg:x="1643" fg:w="10"/><text x="4.4540%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (4 samples, 0.01%)</title><rect x="4.2347%" y="501" width="0.0102%" height="15" fill="rgb(250,166,2)" fg:x="1655" fg:w="4"/><text x="4.4847%" y="511.50"></text></g><g><title>EVP_CIPHER_get_block_size (9 samples, 0.02%)</title><rect x="4.2603%" y="501" width="0.0230%" height="15" fill="rgb(242,216,29)" fg:x="1665" fg:w="9"/><text x="4.5103%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (54 samples, 0.14%)</title><rect x="4.2935%" y="501" width="0.1382%" height="15" fill="rgb(230,116,27)" fg:x="1678" fg:w="54"/><text x="4.5435%" y="511.50"></text></g><g><title>EVP_EncryptUpdate (45 samples, 0.12%)</title><rect x="4.4368%" y="501" width="0.1151%" height="15" fill="rgb(228,99,48)" fg:x="1734" fg:w="45"/><text x="4.6868%" y="511.50"></text></g><g><title>OPENSSL_LH_retrieve (8 samples, 0.02%)</title><rect x="4.5520%" y="501" width="0.0205%" height="15" fill="rgb(253,11,6)" fg:x="1779" fg:w="8"/><text x="4.8020%" y="511.50"></text></g><g><title>OPENSSL_init_crypto (4 samples, 0.01%)</title><rect x="4.5724%" y="501" width="0.0102%" height="15" fill="rgb(247,143,39)" fg:x="1787" fg:w="4"/><text x="4.8224%" y="511.50"></text></g><g><title>OSSL_PARAM_locate (18 samples, 0.05%)</title><rect x="4.5878%" y="501" width="0.0461%" height="15" fill="rgb(236,97,10)" fg:x="1793" fg:w="18"/><text x="4.8378%" y="511.50"></text></g><g><title>[[vdso]] (8 samples, 0.02%)</title><rect x="4.6390%" y="501" width="0.0205%" height="15" fill="rgb(233,208,19)" fg:x="1813" fg:w="8"/><text x="4.8890%" y="511.50"></text></g><g><title>[benchmark] (13 samples, 0.03%)</title><rect x="4.6594%" y="501" width="0.0333%" height="15" fill="rgb(216,164,2)" fg:x="1821" fg:w="13"/><text x="4.9094%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (13 samples, 0.03%)</title><rect x="4.6594%" y="485" width="0.0333%" height="15" fill="rgb(220,129,5)" fg:x="1821" fg:w="13"/><text x="4.9094%" y="495.50"></text></g><g><title>[libc.so.6] (88 samples, 0.23%)</title><rect x="4.6927%" y="501" width="0.2252%" height="15" fill="rgb(242,17,10)" fg:x="1834" fg:w="88"/><text x="4.9427%" y="511.50"></text></g><g><title>[libcrypto.so.3] (322 samples, 0.82%)</title><rect x="4.9179%" y="501" width="0.8239%" height="15" fill="rgb(242,107,0)" fg:x="1922" fg:w="322"/><text x="5.1679%" y="511.50"></text></g><g><title>__bss_start (11 samples, 0.03%)</title><rect x="5.7418%" y="501" width="0.0281%" height="15" fill="rgb(251,28,31)" fg:x="2244" fg:w="11"/><text x="5.9918%" y="511.50"></text></g><g><title>[libcrypto.so.3] (11 samples, 0.03%)</title><rect x="5.7418%" y="485" width="0.0281%" height="15" fill="rgb(233,223,10)" fg:x="2244" fg:w="11"/><text x="5.9918%" y="495.50"></text></g><g><title>__entry_text_start (39 samples, 0.10%)</title><rect x="6.0335%" y="309" width="0.0998%" height="15" fill="rgb(215,21,27)" fg:x="2358" fg:w="39"/><text x="6.2835%" y="319.50"></text></g><g><title>_copy_to_iter (4 samples, 0.01%)</title><rect x="6.1742%" y="261" width="0.0102%" height="15" fill="rgb(232,23,21)" fg:x="2413" fg:w="4"/><text x="6.4242%" y="271.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="6.3610%" y="85" width="0.0128%" height="15" fill="rgb(244,5,23)" fg:x="2486" fg:w="5"/><text x="6.6110%" y="95.50"></text></g><g><title>_copy_to_iter (37 samples, 0.09%)</title><rect x="6.2919%" y="245" width="0.0947%" height="15" fill="rgb(226,81,46)" fg:x="2459" fg:w="37"/><text x="6.5419%" y="255.50"></text></g><g><title>copyout (29 samples, 0.07%)</title><rect x="6.3124%" y="229" width="0.0742%" height="15" fill="rgb(247,70,30)" fg:x="2467" fg:w="29"/><text x="6.5624%" y="239.50"></text></g><g><title>asm_sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="6.3610%" y="213" width="0.0256%" height="15" fill="rgb(212,68,19)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="223.50"></text></g><g><title>sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="6.3610%" y="197" width="0.0256%" height="15" fill="rgb(240,187,13)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="207.50"></text></g><g><title>irqentry_exit (10 samples, 0.03%)</title><rect x="6.3610%" y="181" width="0.0256%" height="15" fill="rgb(223,113,26)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="191.50"></text></g><g><title>raw_irqentry_exit_cond_resched (10 samples, 0.03%)</title><rect x="6.3610%" y="165" width="0.0256%" height="15" fill="rgb(206,192,2)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="175.50"></text></g><g><title>preempt_schedule_irq (10 samples, 0.03%)</title><rect x="6.3610%" y="149" width="0.0256%" height="15" fill="rgb(241,108,4)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="159.50"></text></g><g><title>__schedule (10 samples, 0.03%)</title><rect x="6.3610%" y="133" width="0.0256%" height="15" fill="rgb(247,173,49)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="6.3610%" y="117" width="0.0256%" height="15" fill="rgb(224,114,35)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="6.3610%" y="101" width="0.0256%" height="15" fill="rgb(245,159,27)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="111.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="6.3738%" y="85" width="0.0128%" height="15" fill="rgb(245,172,44)" fg:x="2491" fg:w="5"/><text x="6.6238%" y="95.50"></text></g><g><title>__memcpy (6 samples, 0.02%)</title><rect x="6.4301%" y="229" width="0.0154%" height="15" fill="rgb(236,23,11)" fg:x="2513" fg:w="6"/><text x="6.6801%" y="239.50"></text></g><g><title>chacha_block_generic (225 samples, 0.58%)</title><rect x="6.5171%" y="213" width="0.5757%" height="15" fill="rgb(205,117,38)" fg:x="2547" fg:w="225"/><text x="6.7671%" y="223.50"></text></g><g><title>chacha_permute (202 samples, 0.52%)</title><rect x="6.5759%" y="197" width="0.5169%" height="15" fill="rgb(237,72,25)" fg:x="2570" fg:w="202"/><text x="6.8259%" y="207.50"></text></g><g><title>__x64_sys_getrandom (367 samples, 0.94%)</title><rect x="6.1563%" y="277" width="0.9391%" height="15" fill="rgb(244,70,9)" fg:x="2406" fg:w="367"/><text x="6.4063%" y="287.50"></text></g><g><title>get_random_bytes_user (354 samples, 0.91%)</title><rect x="6.1896%" y="261" width="0.9058%" height="15" fill="rgb(217,125,39)" fg:x="2419" fg:w="354"/><text x="6.4396%" y="271.50"></text></g><g><title>crng_make_state (276 samples, 0.71%)</title><rect x="6.3891%" y="245" width="0.7062%" height="15" fill="rgb(235,36,10)" fg:x="2497" fg:w="276"/><text x="6.6391%" y="255.50"></text></g><g><title>crng_fast_key_erasure (253 samples, 0.65%)</title><rect x="6.4480%" y="229" width="0.6474%" height="15" fill="rgb(251,123,47)" fg:x="2520" fg:w="253"/><text x="6.6980%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (4 samples, 0.01%)</title><rect x="7.0953%" y="277" width="0.0102%" height="15" fill="rgb(221,13,13)" fg:x="2773" fg:w="4"/><text x="7.3453%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (13 samples, 0.03%)</title><rect x="7.1184%" y="261" width="0.0333%" height="15" fill="rgb(238,131,9)" fg:x="2782" fg:w="13"/><text x="7.3684%" y="271.50"></text></g><g><title>fpregs_assert_state_consistent (5 samples, 0.01%)</title><rect x="7.1388%" y="245" width="0.0128%" height="15" fill="rgb(211,50,8)" fg:x="2790" fg:w="5"/><text x="7.3888%" y="255.50"></text></g><g><title>do_syscall_64 (396 samples, 1.01%)</title><rect x="6.1461%" y="293" width="1.0133%" height="15" fill="rgb(245,182,24)" fg:x="2402" fg:w="396"/><text x="6.3961%" y="303.50"></text></g><g><title>syscall_exit_to_user_mode (21 samples, 0.05%)</title><rect x="7.1056%" y="277" width="0.0537%" height="15" fill="rgb(242,14,37)" fg:x="2777" fg:w="21"/><text x="7.3556%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (403 samples, 1.03%)</title><rect x="6.1384%" y="309" width="1.0312%" height="15" fill="rgb(246,228,12)" fg:x="2399" fg:w="403"/><text x="6.3884%" y="319.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::next_u64 (485 samples, 1.24%)</title><rect x="5.9567%" y="485" width="1.2410%" height="15" fill="rgb(213,55,15)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="495.50"></text></g><g><title>rand_core::impls::next_u64_via_fill (485 samples, 1.24%)</title><rect x="5.9567%" y="469" width="1.2410%" height="15" fill="rgb(209,9,3)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="479.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::fill_bytes (485 samples, 1.24%)</title><rect x="5.9567%" y="453" width="1.2410%" height="15" fill="rgb(230,59,30)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="463.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::try_fill_bytes (485 samples, 1.24%)</title><rect x="5.9567%" y="437" width="1.2410%" height="15" fill="rgb(209,121,21)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="447.50"></text></g><g><title>getrandom::getrandom (485 samples, 1.24%)</title><rect x="5.9567%" y="421" width="1.2410%" height="15" fill="rgb(220,109,13)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="431.50"></text></g><g><title>getrandom::getrandom_uninit (485 samples, 1.24%)</title><rect x="5.9567%" y="405" width="1.2410%" height="15" fill="rgb(232,18,1)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="415.50"></text></g><g><title>getrandom::imp::getrandom_inner (484 samples, 1.24%)</title><rect x="5.9593%" y="389" width="1.2384%" height="15" fill="rgb(215,41,42)" fg:x="2329" fg:w="484"/><text x="6.2093%" y="399.50"></text></g><g><title>getrandom::util_libc::sys_fill_exact (484 samples, 1.24%)</title><rect x="5.9593%" y="373" width="1.2384%" height="15" fill="rgb(224,123,36)" fg:x="2329" fg:w="484"/><text x="6.2093%" y="383.50"></text></g><g><title>getrandom::imp::getrandom_inner::_{{closure}} (482 samples, 1.23%)</title><rect x="5.9644%" y="357" width="1.2333%" height="15" fill="rgb(240,125,3)" fg:x="2331" fg:w="482"/><text x="6.2144%" y="367.50"></text></g><g><title>getrandom::imp::getrandom (482 samples, 1.23%)</title><rect x="5.9644%" y="341" width="1.2333%" height="15" fill="rgb(205,98,50)" fg:x="2331" fg:w="482"/><text x="6.2144%" y="351.50"></text></g><g><title>syscall (482 samples, 1.23%)</title><rect x="5.9644%" y="325" width="1.2333%" height="15" fill="rgb(205,185,37)" fg:x="2331" fg:w="482"/><text x="6.2144%" y="335.50"></text></g><g><title>syscall_return_via_sysret (11 samples, 0.03%)</title><rect x="7.1695%" y="309" width="0.0281%" height="15" fill="rgb(238,207,15)" fg:x="2802" fg:w="11"/><text x="7.4195%" y="319.50"></text></g><g><title>[libc.so.6] (18 samples, 0.05%)</title><rect x="7.1977%" y="485" width="0.0461%" height="15" fill="rgb(213,199,42)" fg:x="2813" fg:w="18"/><text x="7.4477%" y="495.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (7 samples, 0.02%)</title><rect x="7.2540%" y="485" width="0.0179%" height="15" fill="rgb(235,201,11)" fg:x="2835" fg:w="7"/><text x="7.5040%" y="495.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="7.2540%" y="469" width="0.0179%" height="15" fill="rgb(207,46,11)" fg:x="2835" fg:w="7"/><text x="7.5040%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (6 samples, 0.02%)</title><rect x="7.2565%" y="453" width="0.0154%" height="15" fill="rgb(241,35,35)" fg:x="2836" fg:w="6"/><text x="7.5065%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_sub (6 samples, 0.02%)</title><rect x="7.2565%" y="437" width="0.0154%" height="15" fill="rgb(243,32,47)" fg:x="2836" fg:w="6"/><text x="7.5065%" y="447.50"></text></g><g><title>_ZN3std4sync4mpmc5array16Channel$LT$T$GT$10start_recv17h7800ca29c64cb868E.llvm.12455019271255371362 (7 samples, 0.02%)</title><rect x="7.3307%" y="437" width="0.0179%" height="15" fill="rgb(247,202,23)" fg:x="2865" fg:w="7"/><text x="7.5807%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map_err (5 samples, 0.01%)</title><rect x="7.3487%" y="437" width="0.0128%" height="15" fill="rgb(219,102,11)" fg:x="2872" fg:w="5"/><text x="7.5987%" y="447.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init (15 samples, 0.04%)</title><rect x="7.3614%" y="421" width="0.0384%" height="15" fill="rgb(243,110,44)" fg:x="2877" fg:w="15"/><text x="7.6114%" y="431.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (17 samples, 0.04%)</title><rect x="7.3614%" y="437" width="0.0435%" height="15" fill="rgb(222,74,54)" fg:x="2877" fg:w="17"/><text x="7.6114%" y="447.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::get_unchecked (8 samples, 0.02%)</title><rect x="7.4843%" y="421" width="0.0205%" height="15" fill="rgb(216,99,12)" fg:x="2925" fg:w="8"/><text x="7.7343%" y="431.50"></text></g><g><title>&lt;usize as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (8 samples, 0.02%)</title><rect x="7.4843%" y="405" width="0.0205%" height="15" fill="rgb(226,22,26)" fg:x="2925" fg:w="8"/><text x="7.7343%" y="415.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::add (8 samples, 0.02%)</title><rect x="7.4843%" y="389" width="0.0205%" height="15" fill="rgb(217,163,10)" fg:x="2925" fg:w="8"/><text x="7.7343%" y="399.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::offset (8 samples, 0.02%)</title><rect x="7.4843%" y="373" width="0.0205%" height="15" fill="rgb(213,25,53)" fg:x="2925" fg:w="8"/><text x="7.7343%" y="383.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (47 samples, 0.12%)</title><rect x="7.5047%" y="421" width="0.1203%" height="15" fill="rgb(252,105,26)" fg:x="2933" fg:w="47"/><text x="7.7547%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (47 samples, 0.12%)</title><rect x="7.5047%" y="405" width="0.1203%" height="15" fill="rgb(220,39,43)" fg:x="2933" fg:w="47"/><text x="7.7547%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (143 samples, 0.37%)</title><rect x="7.6250%" y="421" width="0.3659%" height="15" fill="rgb(229,68,48)" fg:x="2980" fg:w="143"/><text x="7.8750%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_load (143 samples, 0.37%)</title><rect x="7.6250%" y="405" width="0.3659%" height="15" fill="rgb(252,8,32)" fg:x="2980" fg:w="143"/><text x="7.8750%" y="415.50"></text></g><g><title>core::sync::atomic::fence (16 samples, 0.04%)</title><rect x="7.9909%" y="421" width="0.0409%" height="15" fill="rgb(223,20,43)" fg:x="3123" fg:w="16"/><text x="8.2409%" y="431.50"></text></g><g><title>std::sync::mpsc::Receiver&lt;T&gt;::try_recv (299 samples, 0.77%)</title><rect x="7.2744%" y="485" width="0.7651%" height="15" fill="rgb(229,81,49)" fg:x="2843" fg:w="299"/><text x="7.5244%" y="495.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::try_recv (299 samples, 0.77%)</title><rect x="7.2744%" y="469" width="0.7651%" height="15" fill="rgb(236,28,36)" fg:x="2843" fg:w="299"/><text x="7.5244%" y="479.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::try_recv (287 samples, 0.73%)</title><rect x="7.3052%" y="453" width="0.7344%" height="15" fill="rgb(249,185,26)" fg:x="2855" fg:w="287"/><text x="7.5552%" y="463.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (248 samples, 0.63%)</title><rect x="7.4049%" y="437" width="0.6346%" height="15" fill="rgb(249,174,33)" fg:x="2894" fg:w="248"/><text x="7.6549%" y="447.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (6 samples, 0.02%)</title><rect x="8.0395%" y="469" width="0.0154%" height="15" fill="rgb(233,201,37)" fg:x="3142" fg:w="6"/><text x="8.2895%" y="479.50"></text></g><g><title>std::time::Instant::duration_since (6 samples, 0.02%)</title><rect x="8.0395%" y="453" width="0.0154%" height="15" fill="rgb(221,78,26)" fg:x="3142" fg:w="6"/><text x="8.2895%" y="463.50"></text></g><g><title>std::time::Instant::checked_duration_since (5 samples, 0.01%)</title><rect x="8.0421%" y="437" width="0.0128%" height="15" fill="rgb(250,127,30)" fg:x="3143" fg:w="5"/><text x="8.2921%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (5 samples, 0.01%)</title><rect x="8.0421%" y="421" width="0.0128%" height="15" fill="rgb(230,49,44)" fg:x="3143" fg:w="5"/><text x="8.2921%" y="431.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (5 samples, 0.01%)</title><rect x="8.0421%" y="405" width="0.0128%" height="15" fill="rgb(229,67,23)" fg:x="3143" fg:w="5"/><text x="8.2921%" y="415.50"></text></g><g><title>std::time::Instant::elapsed (28 samples, 0.07%)</title><rect x="8.0395%" y="485" width="0.0716%" height="15" fill="rgb(249,83,47)" fg:x="3142" fg:w="28"/><text x="8.2895%" y="495.50"></text></g><g><title>std::time::Instant::now (22 samples, 0.06%)</title><rect x="8.0549%" y="469" width="0.0563%" height="15" fill="rgb(215,43,3)" fg:x="3148" fg:w="22"/><text x="8.3049%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::Instant::now (22 samples, 0.06%)</title><rect x="8.0549%" y="453" width="0.0563%" height="15" fill="rgb(238,154,13)" fg:x="3148" fg:w="22"/><text x="8.3049%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (22 samples, 0.06%)</title><rect x="8.0549%" y="437" width="0.0563%" height="15" fill="rgb(219,56,2)" fg:x="3148" fg:w="22"/><text x="8.3049%" y="447.50"></text></g><g><title>clock_gettime (21 samples, 0.05%)</title><rect x="8.0574%" y="421" width="0.0537%" height="15" fill="rgb(233,0,4)" fg:x="3149" fg:w="21"/><text x="8.3074%" y="431.50"></text></g><g><title>[[vdso]] (21 samples, 0.05%)</title><rect x="8.0574%" y="405" width="0.0537%" height="15" fill="rgb(235,30,7)" fg:x="3149" fg:w="21"/><text x="8.3074%" y="415.50"></text></g><g><title>[[vdso]] (17 samples, 0.04%)</title><rect x="8.0677%" y="389" width="0.0435%" height="15" fill="rgb(250,79,13)" fg:x="3153" fg:w="17"/><text x="8.3177%" y="399.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (386 samples, 0.99%)</title><rect x="8.2851%" y="469" width="0.9877%" height="15" fill="rgb(211,146,34)" fg:x="3238" fg:w="386"/><text x="8.5351%" y="479.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (386 samples, 0.99%)</title><rect x="8.2851%" y="453" width="0.9877%" height="15" fill="rgb(228,22,38)" fg:x="3238" fg:w="386"/><text x="8.5351%" y="463.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (386 samples, 0.99%)</title><rect x="8.2851%" y="437" width="0.9877%" height="15" fill="rgb(235,168,5)" fg:x="3238" fg:w="386"/><text x="8.5351%" y="447.50"></text></g><g><title>&lt;std::sync::mpmc::zero::ZeroToken as core::default::Default&gt;::default (4 samples, 0.01%)</title><rect x="9.2805%" y="469" width="0.0102%" height="15" fill="rgb(221,155,16)" fg:x="3627" fg:w="4"/><text x="9.5305%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (61 samples, 0.16%)</title><rect x="9.3112%" y="453" width="0.1561%" height="15" fill="rgb(215,215,53)" fg:x="3639" fg:w="61"/><text x="9.5612%" y="463.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (61 samples, 0.16%)</title><rect x="9.3112%" y="437" width="0.1561%" height="15" fill="rgb(223,4,10)" fg:x="3639" fg:w="61"/><text x="9.5612%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (58 samples, 0.15%)</title><rect x="9.3189%" y="421" width="0.1484%" height="15" fill="rgb(234,103,6)" fg:x="3642" fg:w="58"/><text x="9.5689%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (56 samples, 0.14%)</title><rect x="9.3240%" y="405" width="0.1433%" height="15" fill="rgb(227,97,0)" fg:x="3644" fg:w="56"/><text x="9.5740%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_swap (56 samples, 0.14%)</title><rect x="9.3240%" y="389" width="0.1433%" height="15" fill="rgb(234,150,53)" fg:x="3644" fg:w="56"/><text x="9.5740%" y="399.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (67 samples, 0.17%)</title><rect x="9.4673%" y="453" width="0.1714%" height="15" fill="rgb(228,201,54)" fg:x="3700" fg:w="67"/><text x="9.7173%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (66 samples, 0.17%)</title><rect x="9.4698%" y="437" width="0.1689%" height="15" fill="rgb(222,22,37)" fg:x="3701" fg:w="66"/><text x="9.7198%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (65 samples, 0.17%)</title><rect x="9.4724%" y="421" width="0.1663%" height="15" fill="rgb(237,53,32)" fg:x="3702" fg:w="65"/><text x="9.7224%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (65 samples, 0.17%)</title><rect x="9.4724%" y="405" width="0.1663%" height="15" fill="rgb(233,25,53)" fg:x="3702" fg:w="65"/><text x="9.7224%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_get_block_size (4 samples, 0.01%)</title><rect x="9.6924%" y="421" width="0.0102%" height="15" fill="rgb(210,40,34)" fg:x="3788" fg:w="4"/><text x="9.9424%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (362 samples, 0.93%)</title><rect x="9.2958%" y="469" width="0.9263%" height="15" fill="rgb(241,220,44)" fg:x="3633" fg:w="362"/><text x="9.5458%" y="479.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (228 samples, 0.58%)</title><rect x="9.6387%" y="453" width="0.5834%" height="15" fill="rgb(235,28,35)" fg:x="3767" fg:w="228"/><text x="9.8887%" y="463.50"></text></g><g><title>EVP_DecryptUpdate (221 samples, 0.57%)</title><rect x="9.6566%" y="437" width="0.5655%" height="15" fill="rgb(210,56,17)" fg:x="3774" fg:w="221"/><text x="9.9066%" y="447.50"></text></g><g><title>[libcrypto.so.3] (203 samples, 0.52%)</title><rect x="9.7027%" y="421" width="0.5194%" height="15" fill="rgb(224,130,29)" fg:x="3792" fg:w="203"/><text x="9.9527%" y="431.50"></text></g><g><title>[libcrypto.so.3] (148 samples, 0.38%)</title><rect x="9.8434%" y="405" width="0.3787%" height="15" fill="rgb(235,212,8)" fg:x="3847" fg:w="148"/><text x="10.0934%" y="415.50"></text></g><g><title>[libcrypto.so.3] (137 samples, 0.35%)</title><rect x="9.8716%" y="389" width="0.3505%" height="15" fill="rgb(223,33,50)" fg:x="3858" fg:w="137"/><text x="10.1216%" y="399.50"></text></g><g><title>__rust_probestack (8 samples, 0.02%)</title><rect x="10.2221%" y="469" width="0.0205%" height="15" fill="rgb(219,149,13)" fg:x="3995" fg:w="8"/><text x="10.4721%" y="479.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade::_{{closure}} (5 samples, 0.01%)</title><rect x="10.2809%" y="405" width="0.0128%" height="15" fill="rgb(250,156,29)" fg:x="4018" fg:w="5"/><text x="10.5309%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (54 samples, 0.14%)</title><rect x="10.2937%" y="405" width="0.1382%" height="15" fill="rgb(216,193,19)" fg:x="4023" fg:w="54"/><text x="10.5437%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (54 samples, 0.14%)</title><rect x="10.2937%" y="389" width="0.1382%" height="15" fill="rgb(216,135,14)" fg:x="4023" fg:w="54"/><text x="10.5437%" y="399.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade (78 samples, 0.20%)</title><rect x="10.2554%" y="437" width="0.1996%" height="15" fill="rgb(241,47,5)" fg:x="4008" fg:w="78"/><text x="10.5054%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_update (72 samples, 0.18%)</title><rect x="10.2707%" y="421" width="0.1842%" height="15" fill="rgb(233,42,35)" fg:x="4014" fg:w="72"/><text x="10.5207%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (9 samples, 0.02%)</title><rect x="10.4319%" y="405" width="0.0230%" height="15" fill="rgb(231,13,6)" fg:x="4077" fg:w="9"/><text x="10.6819%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (9 samples, 0.02%)</title><rect x="10.4319%" y="389" width="0.0230%" height="15" fill="rgb(207,181,40)" fg:x="4077" fg:w="9"/><text x="10.6819%" y="399.50"></text></g><g><title>core::option::Option&lt;T&gt;::map (82 samples, 0.21%)</title><rect x="10.2554%" y="469" width="0.2098%" height="15" fill="rgb(254,173,49)" fg:x="4008" fg:w="82"/><text x="10.5054%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive::_{{closure}} (82 samples, 0.21%)</title><rect x="10.2554%" y="453" width="0.2098%" height="15" fill="rgb(221,1,38)" fg:x="4008" fg:w="82"/><text x="10.5054%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (4 samples, 0.01%)</title><rect x="10.4549%" y="437" width="0.0102%" height="15" fill="rgb(206,124,46)" fg:x="4086" fg:w="4"/><text x="10.7049%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (59 samples, 0.15%)</title><rect x="10.4652%" y="469" width="0.1510%" height="15" fill="rgb(249,21,11)" fg:x="4090" fg:w="59"/><text x="10.7152%" y="479.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (59 samples, 0.15%)</title><rect x="10.4652%" y="453" width="0.1510%" height="15" fill="rgb(222,201,40)" fg:x="4090" fg:w="59"/><text x="10.7152%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (54 samples, 0.14%)</title><rect x="10.4780%" y="437" width="0.1382%" height="15" fill="rgb(235,61,29)" fg:x="4095" fg:w="54"/><text x="10.7280%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_sub (54 samples, 0.14%)</title><rect x="10.4780%" y="421" width="0.1382%" height="15" fill="rgb(219,207,3)" fg:x="4095" fg:w="54"/><text x="10.7280%" y="431.50"></text></g><g><title>[libc.so.6] (33 samples, 0.08%)</title><rect x="11.5501%" y="261" width="0.0844%" height="15" fill="rgb(222,56,46)" fg:x="4514" fg:w="33"/><text x="11.8001%" y="271.50"></text></g><g><title>__entry_text_start (6 samples, 0.02%)</title><rect x="11.7266%" y="245" width="0.0154%" height="15" fill="rgb(239,76,54)" fg:x="4583" fg:w="6"/><text x="11.9766%" y="255.50"></text></g><g><title>futex_unqueue (8 samples, 0.02%)</title><rect x="11.7804%" y="165" width="0.0205%" height="15" fill="rgb(231,124,27)" fg:x="4604" fg:w="8"/><text x="12.0304%" y="175.50"></text></g><g><title>update_curr (13 samples, 0.03%)</title><rect x="11.8725%" y="69" width="0.0333%" height="15" fill="rgb(249,195,6)" fg:x="4640" fg:w="13"/><text x="12.1225%" y="79.50"></text></g><g><title>cpuacct_charge (4 samples, 0.01%)</title><rect x="11.8955%" y="53" width="0.0102%" height="15" fill="rgb(237,174,47)" fg:x="4649" fg:w="4"/><text x="12.1455%" y="63.50"></text></g><g><title>dequeue_task (24 samples, 0.06%)</title><rect x="11.8571%" y="117" width="0.0614%" height="15" fill="rgb(206,201,31)" fg:x="4634" fg:w="24"/><text x="12.1071%" y="127.50"></text></g><g><title>dequeue_task_fair (24 samples, 0.06%)</title><rect x="11.8571%" y="101" width="0.0614%" height="15" fill="rgb(231,57,52)" fg:x="4634" fg:w="24"/><text x="12.1071%" y="111.50"></text></g><g><title>dequeue_entity (24 samples, 0.06%)</title><rect x="11.8571%" y="85" width="0.0614%" height="15" fill="rgb(248,177,22)" fg:x="4634" fg:w="24"/><text x="12.1071%" y="95.50"></text></g><g><title>finish_task_switch.isra.0 (12 samples, 0.03%)</title><rect x="11.9185%" y="117" width="0.0307%" height="15" fill="rgb(215,211,37)" fg:x="4658" fg:w="12"/><text x="12.1685%" y="127.50"></text></g><g><title>raw_spin_rq_unlock (7 samples, 0.02%)</title><rect x="11.9313%" y="101" width="0.0179%" height="15" fill="rgb(241,128,51)" fg:x="4663" fg:w="7"/><text x="12.1813%" y="111.50"></text></g><g><title>prepare_task_switch (14 samples, 0.04%)</title><rect x="11.9518%" y="117" width="0.0358%" height="15" fill="rgb(227,165,31)" fg:x="4671" fg:w="14"/><text x="12.2018%" y="127.50"></text></g><g><title>__perf_event_task_sched_out (4 samples, 0.01%)</title><rect x="11.9774%" y="101" width="0.0102%" height="15" fill="rgb(228,167,24)" fg:x="4681" fg:w="4"/><text x="12.2274%" y="111.50"></text></g><g><title>psi_group_change (16 samples, 0.04%)</title><rect x="12.0106%" y="101" width="0.0409%" height="15" fill="rgb(228,143,12)" fg:x="4694" fg:w="16"/><text x="12.2606%" y="111.50"></text></g><g><title>psi_task_switch (31 samples, 0.08%)</title><rect x="11.9902%" y="117" width="0.0793%" height="15" fill="rgb(249,149,8)" fg:x="4686" fg:w="31"/><text x="12.2402%" y="127.50"></text></g><g><title>sched_clock_cpu (6 samples, 0.02%)</title><rect x="12.0541%" y="101" width="0.0154%" height="15" fill="rgb(243,35,44)" fg:x="4711" fg:w="6"/><text x="12.3041%" y="111.50"></text></g><g><title>__schedule (97 samples, 0.25%)</title><rect x="11.8264%" y="133" width="0.2482%" height="15" fill="rgb(246,89,9)" fg:x="4622" fg:w="97"/><text x="12.0764%" y="143.50"></text></g><g><title>futex_wait_queue (109 samples, 0.28%)</title><rect x="11.8008%" y="165" width="0.2789%" height="15" fill="rgb(233,213,13)" fg:x="4612" fg:w="109"/><text x="12.0508%" y="175.50"></text></g><g><title>schedule (102 samples, 0.26%)</title><rect x="11.8187%" y="149" width="0.2610%" height="15" fill="rgb(233,141,41)" fg:x="4619" fg:w="102"/><text x="12.0687%" y="159.50"></text></g><g><title>__get_user_nocheck_4 (11 samples, 0.03%)</title><rect x="12.0848%" y="149" width="0.0281%" height="15" fill="rgb(239,167,4)" fg:x="4723" fg:w="11"/><text x="12.3348%" y="159.50"></text></g><g><title>futex_q_lock (4 samples, 0.01%)</title><rect x="12.1258%" y="149" width="0.0102%" height="15" fill="rgb(209,217,16)" fg:x="4739" fg:w="4"/><text x="12.3758%" y="159.50"></text></g><g><title>futex_q_unlock (4 samples, 0.01%)</title><rect x="12.1360%" y="149" width="0.0102%" height="15" fill="rgb(219,88,35)" fg:x="4743" fg:w="4"/><text x="12.3860%" y="159.50"></text></g><g><title>futex_wait_setup (28 samples, 0.07%)</title><rect x="12.0797%" y="165" width="0.0716%" height="15" fill="rgb(220,193,23)" fg:x="4721" fg:w="28"/><text x="12.3297%" y="175.50"></text></g><g><title>__x64_sys_futex (156 samples, 0.40%)</title><rect x="11.7548%" y="213" width="0.3992%" height="15" fill="rgb(230,90,52)" fg:x="4594" fg:w="156"/><text x="12.0048%" y="223.50"></text></g><g><title>do_futex (154 samples, 0.39%)</title><rect x="11.7599%" y="197" width="0.3940%" height="15" fill="rgb(252,106,19)" fg:x="4596" fg:w="154"/><text x="12.0099%" y="207.50"></text></g><g><title>futex_wait (153 samples, 0.39%)</title><rect x="11.7624%" y="181" width="0.3915%" height="15" fill="rgb(206,74,20)" fg:x="4597" fg:w="153"/><text x="12.0124%" y="191.50"></text></g><g><title>__rseq_handle_notify_resume (10 samples, 0.03%)</title><rect x="12.1795%" y="165" width="0.0256%" height="15" fill="rgb(230,138,44)" fg:x="4760" fg:w="10"/><text x="12.4295%" y="175.50"></text></g><g><title>exit_to_user_mode_loop (17 samples, 0.04%)</title><rect x="12.1642%" y="181" width="0.0435%" height="15" fill="rgb(235,182,43)" fg:x="4754" fg:w="17"/><text x="12.4142%" y="191.50"></text></g><g><title>do_syscall_64 (183 samples, 0.47%)</title><rect x="11.7445%" y="229" width="0.4682%" height="15" fill="rgb(242,16,51)" fg:x="4590" fg:w="183"/><text x="11.9945%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (22 samples, 0.06%)</title><rect x="12.1565%" y="213" width="0.0563%" height="15" fill="rgb(248,9,4)" fg:x="4751" fg:w="22"/><text x="12.4065%" y="223.50"></text></g><g><title>exit_to_user_mode_prepare (22 samples, 0.06%)</title><rect x="12.1565%" y="197" width="0.0563%" height="15" fill="rgb(210,31,22)" fg:x="4751" fg:w="22"/><text x="12.4065%" y="207.50"></text></g><g><title>__lll_lock_wait_private (227 samples, 0.58%)</title><rect x="11.6345%" y="261" width="0.5808%" height="15" fill="rgb(239,54,39)" fg:x="4547" fg:w="227"/><text x="11.8845%" y="271.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (185 samples, 0.47%)</title><rect x="11.7420%" y="245" width="0.4734%" height="15" fill="rgb(230,99,41)" fg:x="4589" fg:w="185"/><text x="11.9920%" y="255.50"></text></g><g><title>[libc.so.6] (583 samples, 1.49%)</title><rect x="10.7262%" y="277" width="1.4917%" height="15" fill="rgb(253,106,12)" fg:x="4192" fg:w="583"/><text x="10.9762%" y="287.50"></text></g><g><title>__entry_text_start (7 samples, 0.02%)</title><rect x="12.2256%" y="261" width="0.0179%" height="15" fill="rgb(213,46,41)" fg:x="4778" fg:w="7"/><text x="12.4756%" y="271.50"></text></g><g><title>__x64_sys_futex (6 samples, 0.02%)</title><rect x="12.2486%" y="245" width="0.0154%" height="15" fill="rgb(215,133,35)" fg:x="4787" fg:w="6"/><text x="12.4986%" y="255.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="12.2512%" y="229" width="0.0128%" height="15" fill="rgb(213,28,5)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="239.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="12.2512%" y="213" width="0.0128%" height="15" fill="rgb(215,77,49)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="223.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="12.2512%" y="197" width="0.0128%" height="15" fill="rgb(248,100,22)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="207.50"></text></g><g><title>raw_irqentry_exit_cond_resched (5 samples, 0.01%)</title><rect x="12.2512%" y="181" width="0.0128%" height="15" fill="rgb(208,67,9)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="191.50"></text></g><g><title>preempt_schedule_irq (5 samples, 0.01%)</title><rect x="12.2512%" y="165" width="0.0128%" height="15" fill="rgb(219,133,21)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="175.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="12.2512%" y="149" width="0.0128%" height="15" fill="rgb(246,46,29)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="159.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="12.2512%" y="133" width="0.0128%" height="15" fill="rgb(246,185,52)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="143.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="12.2512%" y="117" width="0.0128%" height="15" fill="rgb(252,136,11)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="127.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="12.2512%" y="101" width="0.0128%" height="15" fill="rgb(219,138,53)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="111.50"></text></g><g><title>_raw_spin_lock (8 samples, 0.02%)</title><rect x="12.2793%" y="197" width="0.0205%" height="15" fill="rgb(211,51,23)" fg:x="4799" fg:w="8"/><text x="12.5293%" y="207.50"></text></g><g><title>futex_hash (4 samples, 0.01%)</title><rect x="12.2998%" y="197" width="0.0102%" height="15" fill="rgb(247,221,28)" fg:x="4807" fg:w="4"/><text x="12.5498%" y="207.50"></text></g><g><title>_raw_spin_lock (18 samples, 0.05%)</title><rect x="12.3842%" y="181" width="0.0461%" height="15" fill="rgb(251,222,45)" fg:x="4840" fg:w="18"/><text x="12.6342%" y="191.50"></text></g><g><title>native_queued_spin_lock_slowpath (18 samples, 0.05%)</title><rect x="12.3842%" y="165" width="0.0461%" height="15" fill="rgb(217,162,53)" fg:x="4840" fg:w="18"/><text x="12.6342%" y="175.50"></text></g><g><title>get_futex_key (4 samples, 0.01%)</title><rect x="12.4303%" y="181" width="0.0102%" height="15" fill="rgb(229,93,14)" fg:x="4858" fg:w="4"/><text x="12.6803%" y="191.50"></text></g><g><title>futex_wake (53 samples, 0.14%)</title><rect x="12.3100%" y="197" width="0.1356%" height="15" fill="rgb(209,67,49)" fg:x="4811" fg:w="53"/><text x="12.5600%" y="207.50"></text></g><g><title>__x64_sys_futex (71 samples, 0.18%)</title><rect x="12.2665%" y="229" width="0.1817%" height="15" fill="rgb(213,87,29)" fg:x="4794" fg:w="71"/><text x="12.5165%" y="239.50"></text></g><g><title>do_futex (68 samples, 0.17%)</title><rect x="12.2742%" y="213" width="0.1740%" height="15" fill="rgb(205,151,52)" fg:x="4797" fg:w="68"/><text x="12.5242%" y="223.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="12.4687%" y="197" width="0.0128%" height="15" fill="rgb(253,215,39)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="207.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="12.4687%" y="181" width="0.0128%" height="15" fill="rgb(221,220,41)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="191.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="12.4687%" y="165" width="0.0128%" height="15" fill="rgb(218,133,21)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="175.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="12.4687%" y="149" width="0.0128%" height="15" fill="rgb(221,193,43)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="159.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="12.4687%" y="133" width="0.0128%" height="15" fill="rgb(240,128,52)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="143.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="12.4687%" y="117" width="0.0128%" height="15" fill="rgb(253,114,12)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="127.50"></text></g><g><title>do_syscall_64 (86 samples, 0.22%)</title><rect x="12.2640%" y="245" width="0.2201%" height="15" fill="rgb(215,223,47)" fg:x="4793" fg:w="86"/><text x="12.5140%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (14 samples, 0.04%)</title><rect x="12.4482%" y="229" width="0.0358%" height="15" fill="rgb(248,225,23)" fg:x="4865" fg:w="14"/><text x="12.6982%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (13 samples, 0.03%)</title><rect x="12.4507%" y="213" width="0.0333%" height="15" fill="rgb(250,108,0)" fg:x="4866" fg:w="13"/><text x="12.7007%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (94 samples, 0.24%)</title><rect x="12.2460%" y="261" width="0.2405%" height="15" fill="rgb(228,208,7)" fg:x="4786" fg:w="94"/><text x="12.4960%" y="271.50"></text></g><g><title>alloc::alloc::dealloc (730 samples, 1.87%)</title><rect x="10.6213%" y="309" width="1.8679%" height="15" fill="rgb(244,45,10)" fg:x="4151" fg:w="730"/><text x="10.8713%" y="319.50">a..</text></g><g><title>cfree (727 samples, 1.86%)</title><rect x="10.6289%" y="293" width="1.8602%" height="15" fill="rgb(207,125,25)" fg:x="4154" fg:w="727"/><text x="10.8789%" y="303.50">c..</text></g><g><title>__lll_lock_wake_private (106 samples, 0.27%)</title><rect x="12.2179%" y="277" width="0.2712%" height="15" fill="rgb(210,195,18)" fg:x="4775" fg:w="106"/><text x="12.4679%" y="287.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (732 samples, 1.87%)</title><rect x="10.6213%" y="325" width="1.8730%" height="15" fill="rgb(249,80,12)" fg:x="4151" fg:w="732"/><text x="10.8713%" y="335.50">&lt;..</text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (738 samples, 1.89%)</title><rect x="10.6161%" y="469" width="1.8883%" height="15" fill="rgb(221,65,9)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="479.50">c..</text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (738 samples, 1.89%)</title><rect x="10.6161%" y="453" width="1.8883%" height="15" fill="rgb(235,49,36)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="463.50">&lt;..</text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (738 samples, 1.89%)</title><rect x="10.6161%" y="437" width="1.8883%" height="15" fill="rgb(225,32,20)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="447.50">a..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (738 samples, 1.89%)</title><rect x="10.6161%" y="421" width="1.8883%" height="15" fill="rgb(215,141,46)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="431.50">a..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (738 samples, 1.89%)</title><rect x="10.6161%" y="405" width="1.8883%" height="15" fill="rgb(250,160,47)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="415.50">a..</text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (736 samples, 1.88%)</title><rect x="10.6213%" y="389" width="1.8832%" height="15" fill="rgb(216,222,40)" fg:x="4151" fg:w="736"/><text x="10.8713%" y="399.50">c..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (736 samples, 1.88%)</title><rect x="10.6213%" y="373" width="1.8832%" height="15" fill="rgb(234,217,39)" fg:x="4151" fg:w="736"/><text x="10.8713%" y="383.50">c..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (736 samples, 1.88%)</title><rect x="10.6213%" y="357" width="1.8832%" height="15" fill="rgb(207,178,40)" fg:x="4151" fg:w="736"/><text x="10.8713%" y="367.50">c..</text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (736 samples, 1.88%)</title><rect x="10.6213%" y="341" width="1.8832%" height="15" fill="rgb(221,136,13)" fg:x="4151" fg:w="736"/><text x="10.8713%" y="351.50">&lt;..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::current_memory (4 samples, 0.01%)</title><rect x="12.4942%" y="325" width="0.0102%" height="15" fill="rgb(249,199,10)" fg:x="4883" fg:w="4"/><text x="12.7442%" y="335.50"></text></g><g><title>std::sync::poison::Flag::done (9 samples, 0.02%)</title><rect x="12.5045%" y="437" width="0.0230%" height="15" fill="rgb(249,222,13)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="447.50"></text></g><g><title>std::thread::panicking (9 samples, 0.02%)</title><rect x="12.5045%" y="421" width="0.0230%" height="15" fill="rgb(244,185,38)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="431.50"></text></g><g><title>std::panicking::panicking (9 samples, 0.02%)</title><rect x="12.5045%" y="405" width="0.0230%" height="15" fill="rgb(236,202,9)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="415.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (9 samples, 0.02%)</title><rect x="12.5045%" y="389" width="0.0230%" height="15" fill="rgb(250,229,37)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (9 samples, 0.02%)</title><rect x="12.5045%" y="373" width="0.0230%" height="15" fill="rgb(206,174,23)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (9 samples, 0.02%)</title><rect x="12.5045%" y="357" width="0.0230%" height="15" fill="rgb(211,33,43)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="367.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (76 samples, 0.19%)</title><rect x="12.5045%" y="453" width="0.1945%" height="15" fill="rgb(245,58,50)" fg:x="4887" fg:w="76"/><text x="12.7545%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (67 samples, 0.17%)</title><rect x="12.5275%" y="437" width="0.1714%" height="15" fill="rgb(244,68,36)" fg:x="4896" fg:w="67"/><text x="12.7775%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (65 samples, 0.17%)</title><rect x="12.5326%" y="421" width="0.1663%" height="15" fill="rgb(232,229,15)" fg:x="4898" fg:w="65"/><text x="12.7826%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_swap (65 samples, 0.17%)</title><rect x="12.5326%" y="405" width="0.1663%" height="15" fill="rgb(254,30,23)" fg:x="4898" fg:w="65"/><text x="12.7826%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (77 samples, 0.20%)</title><rect x="12.5045%" y="469" width="0.1970%" height="15" fill="rgb(235,160,14)" fg:x="4887" fg:w="77"/><text x="12.7545%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;std::collections::hash::map::HashMap&lt;core::num::nonzero::NonZeroU32,alloc::sync::Weak&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt;&gt;&gt; (77 samples, 0.20%)</title><rect x="12.7015%" y="469" width="0.1970%" height="15" fill="rgb(212,155,44)" fg:x="4964" fg:w="77"/><text x="12.9515%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (77 samples, 0.20%)</title><rect x="12.7015%" y="453" width="0.1970%" height="15" fill="rgb(226,2,50)" fg:x="4964" fg:w="77"/><text x="12.9515%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (77 samples, 0.20%)</title><rect x="12.7015%" y="437" width="0.1970%" height="15" fill="rgb(234,177,6)" fg:x="4964" fg:w="77"/><text x="12.9515%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (70 samples, 0.18%)</title><rect x="12.7194%" y="421" width="0.1791%" height="15" fill="rgb(217,24,9)" fg:x="4971" fg:w="70"/><text x="12.9694%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (70 samples, 0.18%)</title><rect x="12.7194%" y="405" width="0.1791%" height="15" fill="rgb(220,13,46)" fg:x="4971" fg:w="70"/><text x="12.9694%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (51 samples, 0.13%)</title><rect x="12.8985%" y="469" width="0.1305%" height="15" fill="rgb(239,221,27)" fg:x="5041" fg:w="51"/><text x="13.1485%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (51 samples, 0.13%)</title><rect x="12.8985%" y="453" width="0.1305%" height="15" fill="rgb(222,198,25)" fg:x="5041" fg:w="51"/><text x="13.1485%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (51 samples, 0.13%)</title><rect x="12.8985%" y="437" width="0.1305%" height="15" fill="rgb(211,99,13)" fg:x="5041" fg:w="51"/><text x="13.1485%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (48 samples, 0.12%)</title><rect x="12.9062%" y="421" width="0.1228%" height="15" fill="rgb(232,111,31)" fg:x="5044" fg:w="48"/><text x="13.1562%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (48 samples, 0.12%)</title><rect x="12.9062%" y="405" width="0.1228%" height="15" fill="rgb(245,82,37)" fg:x="5044" fg:w="48"/><text x="13.1562%" y="415.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::c_rounds (7 samples, 0.02%)</title><rect x="13.0674%" y="341" width="0.0179%" height="15" fill="rgb(227,149,46)" fg:x="5107" fg:w="7"/><text x="13.3174%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (6 samples, 0.02%)</title><rect x="13.0700%" y="325" width="0.0154%" height="15" fill="rgb(218,36,50)" fg:x="5108" fg:w="6"/><text x="13.3200%" y="335.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (14 samples, 0.04%)</title><rect x="13.1032%" y="325" width="0.0358%" height="15" fill="rgb(226,80,48)" fg:x="5121" fg:w="14"/><text x="13.3532%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="13.0418%" y="389" width="0.1305%" height="15" fill="rgb(238,224,15)" fg:x="5097" fg:w="51"/><text x="13.2918%" y="399.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="13.0418%" y="373" width="0.1305%" height="15" fill="rgb(241,136,10)" fg:x="5097" fg:w="51"/><text x="13.2918%" y="383.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="13.0418%" y="357" width="0.1305%" height="15" fill="rgb(208,32,45)" fg:x="5097" fg:w="51"/><text x="13.2918%" y="367.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::d_rounds (34 samples, 0.09%)</title><rect x="13.0853%" y="341" width="0.0870%" height="15" fill="rgb(207,135,9)" fg:x="5114" fg:w="34"/><text x="13.3353%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (13 samples, 0.03%)</title><rect x="13.1390%" y="325" width="0.0333%" height="15" fill="rgb(206,86,44)" fg:x="5135" fg:w="13"/><text x="13.3890%" y="335.50"></text></g><g><title>hashbrown::map::make_hash (70 samples, 0.18%)</title><rect x="13.0341%" y="421" width="0.1791%" height="15" fill="rgb(245,177,15)" fg:x="5094" fg:w="70"/><text x="13.2841%" y="431.50"></text></g><g><title>core::hash::BuildHasher::hash_one (70 samples, 0.18%)</title><rect x="13.0341%" y="405" width="0.1791%" height="15" fill="rgb(206,64,50)" fg:x="5094" fg:w="70"/><text x="13.2841%" y="415.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (14 samples, 0.04%)</title><rect x="13.1774%" y="389" width="0.0358%" height="15" fill="rgb(234,36,40)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="399.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (14 samples, 0.04%)</title><rect x="13.1774%" y="373" width="0.0358%" height="15" fill="rgb(213,64,8)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="383.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for u32&gt;::hash (14 samples, 0.04%)</title><rect x="13.1774%" y="357" width="0.0358%" height="15" fill="rgb(210,75,36)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="367.50"></text></g><g><title>core::hash::Hasher::write_u32 (14 samples, 0.04%)</title><rect x="13.1774%" y="341" width="0.0358%" height="15" fill="rgb(229,88,21)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="351.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::write (14 samples, 0.04%)</title><rect x="13.1774%" y="325" width="0.0358%" height="15" fill="rgb(252,204,47)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="335.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::write (14 samples, 0.04%)</title><rect x="13.1774%" y="309" width="0.0358%" height="15" fill="rgb(208,77,27)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="319.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::write (14 samples, 0.04%)</title><rect x="13.1774%" y="293" width="0.0358%" height="15" fill="rgb(221,76,26)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="303.50"></text></g><g><title>core::hash::sip::u8to64_le (11 samples, 0.03%)</title><rect x="13.1851%" y="277" width="0.0281%" height="15" fill="rgb(225,139,18)" fg:x="5153" fg:w="11"/><text x="13.4351%" y="287.50"></text></g><g><title>&lt;hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator&gt;::next (4 samples, 0.01%)</title><rect x="13.2260%" y="373" width="0.0102%" height="15" fill="rgb(230,137,11)" fg:x="5169" fg:w="4"/><text x="13.4760%" y="383.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find::_{{closure}} (8 samples, 0.02%)</title><rect x="13.2363%" y="373" width="0.0205%" height="15" fill="rgb(212,28,1)" fg:x="5173" fg:w="8"/><text x="13.4863%" y="383.50"></text></g><g><title>hashbrown::map::equivalent_key::_{{closure}} (8 samples, 0.02%)</title><rect x="13.2363%" y="357" width="0.0205%" height="15" fill="rgb(248,164,17)" fg:x="5173" fg:w="8"/><text x="13.4863%" y="367.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::cmp::PartialEq&gt;::eq (8 samples, 0.02%)</title><rect x="13.2363%" y="341" width="0.0205%" height="15" fill="rgb(222,171,42)" fg:x="5173" fg:w="8"/><text x="13.4863%" y="351.50"></text></g><g><title>hashbrown::raw::h2 (9 samples, 0.02%)</title><rect x="13.2567%" y="373" width="0.0230%" height="15" fill="rgb(243,84,45)" fg:x="5181" fg:w="9"/><text x="13.5067%" y="383.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (109 samples, 0.28%)</title><rect x="13.0341%" y="437" width="0.2789%" height="15" fill="rgb(252,49,23)" fg:x="5094" fg:w="109"/><text x="13.2841%" y="447.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::get (39 samples, 0.10%)</title><rect x="13.2132%" y="421" width="0.0998%" height="15" fill="rgb(215,19,7)" fg:x="5164" fg:w="39"/><text x="13.4632%" y="431.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find (39 samples, 0.10%)</title><rect x="13.2132%" y="405" width="0.0998%" height="15" fill="rgb(238,81,41)" fg:x="5164" fg:w="39"/><text x="13.4632%" y="415.50"></text></g><g><title>hashbrown::raw::RawTableInner&lt;A&gt;::find_inner (39 samples, 0.10%)</title><rect x="13.2132%" y="389" width="0.0998%" height="15" fill="rgb(210,199,37)" fg:x="5164" fg:w="39"/><text x="13.4632%" y="399.50"></text></g><g><title>hashbrown::raw::sse2::Group::load (13 samples, 0.03%)</title><rect x="13.2798%" y="373" width="0.0333%" height="15" fill="rgb(244,192,49)" fg:x="5190" fg:w="13"/><text x="13.5298%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_loadu_si128 (13 samples, 0.03%)</title><rect x="13.2798%" y="357" width="0.0333%" height="15" fill="rgb(226,211,11)" fg:x="5190" fg:w="13"/><text x="13.5298%" y="367.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (13 samples, 0.03%)</title><rect x="13.2798%" y="341" width="0.0333%" height="15" fill="rgb(236,162,54)" fg:x="5190" fg:w="13"/><text x="13.5298%" y="351.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (113 samples, 0.29%)</title><rect x="13.0341%" y="469" width="0.2891%" height="15" fill="rgb(220,229,9)" fg:x="5094" fg:w="113"/><text x="13.2841%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (113 samples, 0.29%)</title><rect x="13.0341%" y="453" width="0.2891%" height="15" fill="rgb(250,87,22)" fg:x="5094" fg:w="113"/><text x="13.2841%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (4 samples, 0.01%)</title><rect x="13.3130%" y="437" width="0.0102%" height="15" fill="rgb(239,43,17)" fg:x="5203" fg:w="4"/><text x="13.5630%" y="447.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (6 samples, 0.02%)</title><rect x="13.3233%" y="437" width="0.0154%" height="15" fill="rgb(231,177,25)" fg:x="5207" fg:w="6"/><text x="13.5733%" y="447.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (14 samples, 0.04%)</title><rect x="13.3233%" y="453" width="0.0358%" height="15" fill="rgb(219,179,1)" fg:x="5207" fg:w="14"/><text x="13.5733%" y="463.50"></text></g><g><title>std::sync::poison::Flag::guard (8 samples, 0.02%)</title><rect x="13.3386%" y="437" width="0.0205%" height="15" fill="rgb(238,219,53)" fg:x="5213" fg:w="8"/><text x="13.5886%" y="447.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (47 samples, 0.12%)</title><rect x="13.3233%" y="469" width="0.1203%" height="15" fill="rgb(232,167,36)" fg:x="5207" fg:w="47"/><text x="13.5733%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (33 samples, 0.08%)</title><rect x="13.3591%" y="453" width="0.0844%" height="15" fill="rgb(244,19,51)" fg:x="5221" fg:w="33"/><text x="13.6091%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (32 samples, 0.08%)</title><rect x="13.3616%" y="437" width="0.0819%" height="15" fill="rgb(224,6,22)" fg:x="5222" fg:w="32"/><text x="13.6116%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (32 samples, 0.08%)</title><rect x="13.3616%" y="421" width="0.0819%" height="15" fill="rgb(224,145,5)" fg:x="5222" fg:w="32"/><text x="13.6116%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (117 samples, 0.30%)</title><rect x="13.4870%" y="437" width="0.2994%" height="15" fill="rgb(234,130,49)" fg:x="5271" fg:w="117"/><text x="13.7370%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (117 samples, 0.30%)</title><rect x="13.4870%" y="421" width="0.2994%" height="15" fill="rgb(254,6,2)" fg:x="5271" fg:w="117"/><text x="13.7370%" y="431.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (140 samples, 0.36%)</title><rect x="13.4435%" y="469" width="0.3582%" height="15" fill="rgb(208,96,46)" fg:x="5254" fg:w="140"/><text x="13.6935%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (140 samples, 0.36%)</title><rect x="13.4435%" y="453" width="0.3582%" height="15" fill="rgb(239,3,39)" fg:x="5254" fg:w="140"/><text x="13.6935%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::is_read_lockable (6 samples, 0.02%)</title><rect x="13.7864%" y="437" width="0.0154%" height="15" fill="rgb(233,210,1)" fg:x="5388" fg:w="6"/><text x="14.0364%" y="447.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::check (7 samples, 0.02%)</title><rect x="13.8018%" y="469" width="0.0179%" height="15" fill="rgb(244,137,37)" fg:x="5394" fg:w="7"/><text x="14.0518%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicU64::load (6 samples, 0.02%)</title><rect x="13.8043%" y="453" width="0.0154%" height="15" fill="rgb(240,136,2)" fg:x="5395" fg:w="6"/><text x="14.0543%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="13.8043%" y="437" width="0.0154%" height="15" fill="rgb(239,18,37)" fg:x="5395" fg:w="6"/><text x="14.0543%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::push (16 samples, 0.04%)</title><rect x="13.8734%" y="453" width="0.0409%" height="15" fill="rgb(218,185,22)" fg:x="5422" fg:w="16"/><text x="14.1234%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push (16 samples, 0.04%)</title><rect x="13.8734%" y="437" width="0.0409%" height="15" fill="rgb(225,218,4)" fg:x="5422" fg:w="16"/><text x="14.1234%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::try_push (16 samples, 0.04%)</title><rect x="13.8734%" y="421" width="0.0409%" height="15" fill="rgb(230,182,32)" fg:x="5422" fg:w="16"/><text x="14.1234%" y="431.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push_unchecked (14 samples, 0.04%)</title><rect x="13.8785%" y="405" width="0.0358%" height="15" fill="rgb(242,56,43)" fg:x="5424" fg:w="14"/><text x="14.1285%" y="415.50"></text></g><g><title>core::ptr::write (12 samples, 0.03%)</title><rect x="13.8836%" y="389" width="0.0307%" height="15" fill="rgb(233,99,24)" fg:x="5426" fg:w="12"/><text x="14.1336%" y="399.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::write (4 samples, 0.01%)</title><rect x="13.9297%" y="453" width="0.0102%" height="15" fill="rgb(234,209,42)" fg:x="5444" fg:w="4"/><text x="14.1797%" y="463.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (51 samples, 0.13%)</title><rect x="13.8197%" y="469" width="0.1305%" height="15" fill="rgb(227,7,12)" fg:x="5401" fg:w="51"/><text x="14.0697%" y="479.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (28 samples, 0.07%)</title><rect x="13.9578%" y="453" width="0.0716%" height="15" fill="rgb(245,203,43)" fg:x="5455" fg:w="28"/><text x="14.2078%" y="463.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (28 samples, 0.07%)</title><rect x="13.9578%" y="437" width="0.0716%" height="15" fill="rgb(238,205,33)" fg:x="5455" fg:w="28"/><text x="14.2078%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (28 samples, 0.07%)</title><rect x="13.9578%" y="421" width="0.0716%" height="15" fill="rgb(231,56,7)" fg:x="5455" fg:w="28"/><text x="14.2078%" y="431.50"></text></g><g><title>zssp::zeta::from_nonce (33 samples, 0.08%)</title><rect x="13.9502%" y="469" width="0.0844%" height="15" fill="rgb(244,186,29)" fg:x="5452" fg:w="33"/><text x="14.2002%" y="479.50"></text></g><g><title>&lt;core::slice::iter::IterMut&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::next (6 samples, 0.02%)</title><rect x="14.0474%" y="453" width="0.0154%" height="15" fill="rgb(234,111,31)" fg:x="5490" fg:w="6"/><text x="14.2974%" y="463.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (76 samples, 0.19%)</title><rect x="14.0627%" y="453" width="0.1945%" height="15" fill="rgb(241,149,10)" fg:x="5496" fg:w="76"/><text x="14.3127%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (76 samples, 0.19%)</title><rect x="14.0627%" y="437" width="0.1945%" height="15" fill="rgb(249,206,44)" fg:x="5496" fg:w="76"/><text x="14.3127%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (75 samples, 0.19%)</title><rect x="14.0653%" y="421" width="0.1919%" height="15" fill="rgb(251,153,30)" fg:x="5497" fg:w="75"/><text x="14.3153%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (75 samples, 0.19%)</title><rect x="14.0653%" y="405" width="0.1919%" height="15" fill="rgb(239,152,38)" fg:x="5497" fg:w="75"/><text x="14.3153%" y="415.50"></text></g><g><title>CRYPTO_gcm128_decrypt (231 samples, 0.59%)</title><rect x="14.6615%" y="357" width="0.5911%" height="15" fill="rgb(249,139,47)" fg:x="5730" fg:w="231"/><text x="14.9115%" y="367.50"></text></g><g><title>[libcrypto.so.3] (86 samples, 0.22%)</title><rect x="15.0325%" y="341" width="0.2201%" height="15" fill="rgb(244,64,35)" fg:x="5875" fg:w="86"/><text x="15.2825%" y="351.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (440 samples, 1.13%)</title><rect x="15.2525%" y="357" width="1.1258%" height="15" fill="rgb(216,46,15)" fg:x="5961" fg:w="440"/><text x="15.5025%" y="367.50"></text></g><g><title>[libcrypto.so.3] (352 samples, 0.90%)</title><rect x="15.4777%" y="341" width="0.9007%" height="15" fill="rgb(250,74,19)" fg:x="6049" fg:w="352"/><text x="15.7277%" y="351.50"></text></g><g><title>[libcrypto.so.3] (27 samples, 0.07%)</title><rect x="16.3093%" y="325" width="0.0691%" height="15" fill="rgb(249,42,33)" fg:x="6374" fg:w="27"/><text x="16.5593%" y="335.50"></text></g><g><title>CRYPTO_gcm128_setiv (23 samples, 0.06%)</title><rect x="16.3784%" y="357" width="0.0589%" height="15" fill="rgb(242,149,17)" fg:x="6401" fg:w="23"/><text x="16.6284%" y="367.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="16.3861%" y="341" width="0.0512%" height="15" fill="rgb(244,29,21)" fg:x="6404" fg:w="20"/><text x="16.6361%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (4,270 samples, 10.93%)</title><rect x="14.2572%" y="453" width="10.9257%" height="15" fill="rgb(220,130,37)" fg:x="5572" fg:w="4270"/><text x="14.5072%" y="463.50">&lt;zssp::crypto_im..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4,270 samples, 10.93%)</title><rect x="14.2572%" y="437" width="10.9257%" height="15" fill="rgb(211,67,2)" fg:x="5572" fg:w="4270"/><text x="14.5072%" y="447.50">zssp::crypto_imp..</text></g><g><title>EVP_DecryptUpdate (4,266 samples, 10.92%)</title><rect x="14.2674%" y="421" width="10.9155%" height="15" fill="rgb(235,68,52)" fg:x="5576" fg:w="4266"/><text x="14.5174%" y="431.50">EVP_DecryptUpdate</text></g><g><title>[libcrypto.so.3] (4,171 samples, 10.67%)</title><rect x="14.5105%" y="405" width="10.6724%" height="15" fill="rgb(246,142,3)" fg:x="5671" fg:w="4171"/><text x="14.7605%" y="415.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,167 samples, 10.66%)</title><rect x="14.5208%" y="389" width="10.6622%" height="15" fill="rgb(241,25,7)" fg:x="5675" fg:w="4167"/><text x="14.7708%" y="399.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,144 samples, 10.60%)</title><rect x="14.5796%" y="373" width="10.6033%" height="15" fill="rgb(242,119,39)" fg:x="5698" fg:w="4144"/><text x="14.8296%" y="383.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,418 samples, 8.75%)</title><rect x="16.4372%" y="357" width="8.7457%" height="15" fill="rgb(241,98,45)" fg:x="6424" fg:w="3418"/><text x="16.6872%" y="367.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,257 samples, 8.33%)</title><rect x="16.8492%" y="341" width="8.3338%" height="15" fill="rgb(254,28,30)" fg:x="6585" fg:w="3257"/><text x="17.0992%" y="351.50">[libcrypto.s..</text></g><g><title>asm_sysvec_reschedule_ipi (17 samples, 0.04%)</title><rect x="25.1395%" y="325" width="0.0435%" height="15" fill="rgb(241,142,54)" fg:x="9825" fg:w="17"/><text x="25.3895%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (16 samples, 0.04%)</title><rect x="25.1420%" y="309" width="0.0409%" height="15" fill="rgb(222,85,15)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="319.50"></text></g><g><title>irqentry_exit (16 samples, 0.04%)</title><rect x="25.1420%" y="293" width="0.0409%" height="15" fill="rgb(210,85,47)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (16 samples, 0.04%)</title><rect x="25.1420%" y="277" width="0.0409%" height="15" fill="rgb(224,206,25)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (16 samples, 0.04%)</title><rect x="25.1420%" y="261" width="0.0409%" height="15" fill="rgb(243,201,19)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (16 samples, 0.04%)</title><rect x="25.1420%" y="245" width="0.0409%" height="15" fill="rgb(236,59,4)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="255.50"></text></g><g><title>schedule (15 samples, 0.04%)</title><rect x="25.1446%" y="229" width="0.0384%" height="15" fill="rgb(254,179,45)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="239.50"></text></g><g><title>__schedule (15 samples, 0.04%)</title><rect x="25.1446%" y="213" width="0.0384%" height="15" fill="rgb(226,14,10)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (15 samples, 0.04%)</title><rect x="25.1446%" y="197" width="0.0384%" height="15" fill="rgb(244,27,41)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (15 samples, 0.04%)</title><rect x="25.1446%" y="181" width="0.0384%" height="15" fill="rgb(235,35,32)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="191.50"></text></g><g><title>perf_ctx_enable (15 samples, 0.04%)</title><rect x="25.1446%" y="165" width="0.0384%" height="15" fill="rgb(218,68,31)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="175.50"></text></g><g><title>CRYPTO_clear_free (92 samples, 0.24%)</title><rect x="25.2392%" y="357" width="0.2354%" height="15" fill="rgb(207,120,37)" fg:x="9864" fg:w="92"/><text x="25.4892%" y="367.50"></text></g><g><title>OPENSSL_cleanse (92 samples, 0.24%)</title><rect x="25.2392%" y="341" width="0.2354%" height="15" fill="rgb(227,98,0)" fg:x="9864" fg:w="92"/><text x="25.4892%" y="351.50"></text></g><g><title>EVP_CIPHER_free (27 samples, 0.07%)</title><rect x="25.4746%" y="357" width="0.0691%" height="15" fill="rgb(207,7,3)" fg:x="9956" fg:w="27"/><text x="25.7246%" y="367.50"></text></g><g><title>cfree (42 samples, 0.11%)</title><rect x="25.5463%" y="357" width="0.1075%" height="15" fill="rgb(206,98,19)" fg:x="9984" fg:w="42"/><text x="25.7963%" y="367.50"></text></g><g><title>[libc.so.6] (7 samples, 0.02%)</title><rect x="25.6358%" y="341" width="0.0179%" height="15" fill="rgb(217,5,26)" fg:x="10019" fg:w="7"/><text x="25.8858%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_free (184 samples, 0.47%)</title><rect x="25.1855%" y="389" width="0.4708%" height="15" fill="rgb(235,190,38)" fg:x="9843" fg:w="184"/><text x="25.4355%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_reset (180 samples, 0.46%)</title><rect x="25.1957%" y="373" width="0.4606%" height="15" fill="rgb(247,86,24)" fg:x="9847" fg:w="180"/><text x="25.4457%" y="383.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec&gt; (210 samples, 0.54%)</title><rect x="25.1829%" y="437" width="0.5373%" height="15" fill="rgb(205,101,16)" fg:x="9842" fg:w="210"/><text x="25.4329%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::CipherCtx&gt; (210 samples, 0.54%)</title><rect x="25.1829%" y="421" width="0.5373%" height="15" fill="rgb(246,168,33)" fg:x="9842" fg:w="210"/><text x="25.4329%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::CipherCtx as core::ops::drop::Drop&gt;::drop (210 samples, 0.54%)</title><rect x="25.1829%" y="405" width="0.5373%" height="15" fill="rgb(231,114,1)" fg:x="9842" fg:w="210"/><text x="25.4329%" y="415.50"></text></g><g><title>cfree (25 samples, 0.06%)</title><rect x="25.6563%" y="389" width="0.0640%" height="15" fill="rgb(207,184,53)" fg:x="10027" fg:w="25"/><text x="25.9063%" y="399.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="25.6819%" y="373" width="0.0384%" height="15" fill="rgb(224,95,51)" fg:x="10037" fg:w="15"/><text x="25.9319%" y="383.50"></text></g><g><title>CRYPTO_gcm128_finish (29 samples, 0.07%)</title><rect x="25.7587%" y="357" width="0.0742%" height="15" fill="rgb(212,188,45)" fg:x="10067" fg:w="29"/><text x="26.0087%" y="367.50"></text></g><g><title>[libcrypto.so.3] (18 samples, 0.05%)</title><rect x="25.7868%" y="341" width="0.0461%" height="15" fill="rgb(223,154,38)" fg:x="10078" fg:w="18"/><text x="26.0368%" y="351.50"></text></g><g><title>[libcrypto.so.3] (33 samples, 0.08%)</title><rect x="25.7510%" y="373" width="0.0844%" height="15" fill="rgb(251,22,52)" fg:x="10064" fg:w="33"/><text x="26.0010%" y="383.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (46 samples, 0.12%)</title><rect x="25.7203%" y="437" width="0.1177%" height="15" fill="rgb(229,209,22)" fg:x="10052" fg:w="46"/><text x="25.9703%" y="447.50"></text></g><g><title>EVP_DecryptFinal_ex (45 samples, 0.12%)</title><rect x="25.7228%" y="421" width="0.1151%" height="15" fill="rgb(234,138,34)" fg:x="10053" fg:w="45"/><text x="25.9728%" y="431.50"></text></g><g><title>[libcrypto.so.3] (38 samples, 0.10%)</title><rect x="25.7408%" y="405" width="0.0972%" height="15" fill="rgb(212,95,11)" fg:x="10060" fg:w="38"/><text x="25.9908%" y="415.50"></text></g><g><title>[libcrypto.so.3] (37 samples, 0.09%)</title><rect x="25.7433%" y="389" width="0.0947%" height="15" fill="rgb(240,179,47)" fg:x="10061" fg:w="37"/><text x="25.9933%" y="399.50"></text></g><g><title>OSSL_PARAM_get_octet_string (6 samples, 0.02%)</title><rect x="25.9429%" y="389" width="0.0154%" height="15" fill="rgb(240,163,11)" fg:x="10139" fg:w="6"/><text x="26.1929%" y="399.50"></text></g><g><title>[libc.so.6] (17 samples, 0.04%)</title><rect x="25.9787%" y="373" width="0.0435%" height="15" fill="rgb(236,37,12)" fg:x="10153" fg:w="17"/><text x="26.2287%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (26 samples, 0.07%)</title><rect x="25.9582%" y="389" width="0.0665%" height="15" fill="rgb(232,164,16)" fg:x="10145" fg:w="26"/><text x="26.2082%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (333 samples, 0.85%)</title><rect x="25.1829%" y="453" width="0.8521%" height="15" fill="rgb(244,205,15)" fg:x="9842" fg:w="333"/><text x="25.4329%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::set_tag (77 samples, 0.20%)</title><rect x="25.8380%" y="437" width="0.1970%" height="15" fill="rgb(223,117,47)" fg:x="10098" fg:w="77"/><text x="26.0880%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (77 samples, 0.20%)</title><rect x="25.8380%" y="421" width="0.1970%" height="15" fill="rgb(244,107,35)" fg:x="10098" fg:w="77"/><text x="26.0880%" y="431.50"></text></g><g><title>[libcrypto.so.3] (39 samples, 0.10%)</title><rect x="25.9352%" y="405" width="0.0998%" height="15" fill="rgb(205,140,8)" fg:x="10136" fg:w="39"/><text x="26.1852%" y="415.50"></text></g><g><title>OSSL_PARAM_locate_const (4 samples, 0.01%)</title><rect x="26.0248%" y="389" width="0.0102%" height="15" fill="rgb(228,84,46)" fg:x="10171" fg:w="4"/><text x="26.2748%" y="399.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="26.1450%" y="389" width="0.0384%" height="15" fill="rgb(254,188,9)" fg:x="10218" fg:w="15"/><text x="26.3950%" y="399.50"></text></g><g><title>OSSL_PARAM_locate (28 samples, 0.07%)</title><rect x="26.1194%" y="405" width="0.0716%" height="15" fill="rgb(206,112,54)" fg:x="10208" fg:w="28"/><text x="26.3694%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (64 samples, 0.16%)</title><rect x="26.0350%" y="437" width="0.1638%" height="15" fill="rgb(216,84,49)" fg:x="10175" fg:w="64"/><text x="26.2850%" y="447.50"></text></g><g><title>[libcrypto.so.3] (42 samples, 0.11%)</title><rect x="26.0913%" y="421" width="0.1075%" height="15" fill="rgb(214,194,35)" fg:x="10197" fg:w="42"/><text x="26.3413%" y="431.50"></text></g><g><title>[libc.so.6] (25 samples, 0.06%)</title><rect x="26.3855%" y="341" width="0.0640%" height="15" fill="rgb(249,28,3)" fg:x="10312" fg:w="25"/><text x="26.6355%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (48 samples, 0.12%)</title><rect x="26.3446%" y="357" width="0.1228%" height="15" fill="rgb(222,56,52)" fg:x="10296" fg:w="48"/><text x="26.5946%" y="367.50"></text></g><g><title>strcmp@plt (7 samples, 0.02%)</title><rect x="26.4495%" y="341" width="0.0179%" height="15" fill="rgb(245,217,50)" fg:x="10337" fg:w="7"/><text x="26.6995%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (81 samples, 0.21%)</title><rect x="26.2678%" y="389" width="0.2073%" height="15" fill="rgb(213,201,24)" fg:x="10266" fg:w="81"/><text x="26.5178%" y="399.50"></text></g><g><title>[libcrypto.so.3] (63 samples, 0.16%)</title><rect x="26.3139%" y="373" width="0.1612%" height="15" fill="rgb(248,116,28)" fg:x="10284" fg:w="63"/><text x="26.5639%" y="383.50"></text></g><g><title>[libc.so.6] (20 samples, 0.05%)</title><rect x="26.5672%" y="341" width="0.0512%" height="15" fill="rgb(219,72,43)" fg:x="10383" fg:w="20"/><text x="26.8172%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (41 samples, 0.10%)</title><rect x="26.5212%" y="357" width="0.1049%" height="15" fill="rgb(209,138,14)" fg:x="10365" fg:w="41"/><text x="26.7712%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_key_length (60 samples, 0.15%)</title><rect x="26.4751%" y="389" width="0.1535%" height="15" fill="rgb(222,18,33)" fg:x="10347" fg:w="60"/><text x="26.7251%" y="399.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="26.4930%" y="373" width="0.1356%" height="15" fill="rgb(213,199,7)" fg:x="10354" fg:w="53"/><text x="26.7430%" y="383.50"></text></g><g><title>pthread_rwlock_rdlock (159 samples, 0.41%)</title><rect x="26.6747%" y="325" width="0.4068%" height="15" fill="rgb(250,110,10)" fg:x="10425" fg:w="159"/><text x="26.9247%" y="335.50"></text></g><g><title>CRYPTO_THREAD_read_lock (163 samples, 0.42%)</title><rect x="26.6696%" y="341" width="0.4171%" height="15" fill="rgb(248,123,6)" fg:x="10423" fg:w="163"/><text x="26.9196%" y="351.50"></text></g><g><title>pthread_rwlock_unlock (79 samples, 0.20%)</title><rect x="27.0994%" y="325" width="0.2021%" height="15" fill="rgb(206,91,31)" fg:x="10591" fg:w="79"/><text x="27.3494%" y="335.50"></text></g><g><title>CRYPTO_THREAD_unlock (86 samples, 0.22%)</title><rect x="27.0943%" y="341" width="0.2201%" height="15" fill="rgb(211,154,13)" fg:x="10589" fg:w="86"/><text x="27.3443%" y="351.50"></text></g><g><title>pthread_rwlock_unlock@plt (5 samples, 0.01%)</title><rect x="27.3016%" y="325" width="0.0128%" height="15" fill="rgb(225,148,7)" fg:x="10670" fg:w="5"/><text x="27.5516%" y="335.50"></text></g><g><title>EVP_CIPHER_up_ref (42 samples, 0.11%)</title><rect x="27.3195%" y="341" width="0.1075%" height="15" fill="rgb(220,160,43)" fg:x="10677" fg:w="42"/><text x="27.5695%" y="351.50"></text></g><g><title>OPENSSL_LH_retrieve (70 samples, 0.18%)</title><rect x="27.4269%" y="341" width="0.1791%" height="15" fill="rgb(213,52,39)" fg:x="10719" fg:w="70"/><text x="27.6769%" y="351.50"></text></g><g><title>[libcrypto.so.3] (57 samples, 0.15%)</title><rect x="27.4602%" y="325" width="0.1458%" height="15" fill="rgb(243,137,7)" fg:x="10732" fg:w="57"/><text x="27.7102%" y="335.50"></text></g><g><title>[libcrypto.so.3] (6 samples, 0.02%)</title><rect x="27.5907%" y="309" width="0.0154%" height="15" fill="rgb(230,79,13)" fg:x="10783" fg:w="6"/><text x="27.8407%" y="319.50"></text></g><g><title>pthread_rwlock_rdlock (43 samples, 0.11%)</title><rect x="27.6240%" y="309" width="0.1100%" height="15" fill="rgb(247,105,23)" fg:x="10796" fg:w="43"/><text x="27.8740%" y="319.50"></text></g><g><title>CRYPTO_THREAD_read_lock (47 samples, 0.12%)</title><rect x="27.6189%" y="325" width="0.1203%" height="15" fill="rgb(223,179,41)" fg:x="10794" fg:w="47"/><text x="27.8689%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (66 samples, 0.17%)</title><rect x="27.7391%" y="309" width="0.1689%" height="15" fill="rgb(218,9,34)" fg:x="10841" fg:w="66"/><text x="27.9891%" y="319.50"></text></g><g><title>CRYPTO_THREAD_unlock (69 samples, 0.18%)</title><rect x="27.7391%" y="325" width="0.1766%" height="15" fill="rgb(222,106,8)" fg:x="10841" fg:w="69"/><text x="27.9891%" y="335.50"></text></g><g><title>CRYPTO_strndup (13 samples, 0.03%)</title><rect x="27.9157%" y="325" width="0.0333%" height="15" fill="rgb(211,220,0)" fg:x="10910" fg:w="13"/><text x="28.1657%" y="335.50"></text></g><g><title>OPENSSL_strcasecmp (38 samples, 0.10%)</title><rect x="28.1741%" y="293" width="0.0972%" height="15" fill="rgb(229,52,16)" fg:x="11011" fg:w="38"/><text x="28.4241%" y="303.50"></text></g><g><title>OPENSSL_LH_retrieve (162 samples, 0.41%)</title><rect x="27.9489%" y="325" width="0.4145%" height="15" fill="rgb(212,155,18)" fg:x="10923" fg:w="162"/><text x="28.1989%" y="335.50"></text></g><g><title>[libcrypto.so.3] (151 samples, 0.39%)</title><rect x="27.9771%" y="309" width="0.3864%" height="15" fill="rgb(242,21,14)" fg:x="10934" fg:w="151"/><text x="28.2271%" y="319.50"></text></g><g><title>[libcrypto.so.3] (36 samples, 0.09%)</title><rect x="28.2713%" y="293" width="0.0921%" height="15" fill="rgb(222,19,48)" fg:x="11049" fg:w="36"/><text x="28.5213%" y="303.50"></text></g><g><title>cfree (12 samples, 0.03%)</title><rect x="28.3686%" y="325" width="0.0307%" height="15" fill="rgb(232,45,27)" fg:x="11087" fg:w="12"/><text x="28.6186%" y="335.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="28.3890%" y="309" width="0.0102%" height="15" fill="rgb(249,103,42)" fg:x="11095" fg:w="4"/><text x="28.6390%" y="319.50"></text></g><g><title>[libcrypto.so.3] (310 samples, 0.79%)</title><rect x="27.6086%" y="341" width="0.7932%" height="15" fill="rgb(246,81,33)" fg:x="10790" fg:w="310"/><text x="27.8586%" y="351.50"></text></g><g><title>pthread_getspecific (7 samples, 0.02%)</title><rect x="28.4018%" y="341" width="0.0179%" height="15" fill="rgb(252,33,42)" fg:x="11100" fg:w="7"/><text x="28.6518%" y="351.50"></text></g><g><title>EVP_CIPHER_fetch (702 samples, 1.80%)</title><rect x="26.6286%" y="389" width="1.7962%" height="15" fill="rgb(209,212,41)" fg:x="10407" fg:w="702"/><text x="26.8786%" y="399.50">E..</text></g><g><title>[libcrypto.so.3] (699 samples, 1.79%)</title><rect x="26.6363%" y="373" width="1.7885%" height="15" fill="rgb(207,154,6)" fg:x="10410" fg:w="699"/><text x="26.8863%" y="383.50">[..</text></g><g><title>[libcrypto.so.3] (690 samples, 1.77%)</title><rect x="26.6593%" y="357" width="1.7655%" height="15" fill="rgb(223,64,47)" fg:x="10419" fg:w="690"/><text x="26.9093%" y="367.50"></text></g><g><title>EVP_CIPHER_free (18 samples, 0.05%)</title><rect x="28.4249%" y="389" width="0.0461%" height="15" fill="rgb(211,161,38)" fg:x="11109" fg:w="18"/><text x="28.6749%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (27 samples, 0.07%)</title><rect x="28.4709%" y="389" width="0.0691%" height="15" fill="rgb(219,138,40)" fg:x="11127" fg:w="27"/><text x="28.7209%" y="399.50"></text></g><g><title>[libc.so.6] (10 samples, 0.03%)</title><rect x="28.5707%" y="357" width="0.0256%" height="15" fill="rgb(241,228,46)" fg:x="11166" fg:w="10"/><text x="28.8207%" y="367.50"></text></g><g><title>malloc (9 samples, 0.02%)</title><rect x="28.5963%" y="357" width="0.0230%" height="15" fill="rgb(223,209,38)" fg:x="11176" fg:w="9"/><text x="28.8463%" y="367.50"></text></g><g><title>CRYPTO_zalloc (22 samples, 0.06%)</title><rect x="28.5656%" y="373" width="0.0563%" height="15" fill="rgb(236,164,45)" fg:x="11164" fg:w="22"/><text x="28.8156%" y="383.50"></text></g><g><title>OPENSSL_init_crypto (4 samples, 0.01%)</title><rect x="28.6219%" y="373" width="0.0102%" height="15" fill="rgb(231,15,5)" fg:x="11186" fg:w="4"/><text x="28.8719%" y="383.50"></text></g><g><title>CRYPTO_gcm128_init (155 samples, 0.40%)</title><rect x="28.6398%" y="357" width="0.3966%" height="15" fill="rgb(252,35,15)" fg:x="11193" fg:w="155"/><text x="28.8898%" y="367.50"></text></g><g><title>[libcrypto.so.3] (126 samples, 0.32%)</title><rect x="28.7140%" y="341" width="0.3224%" height="15" fill="rgb(248,181,18)" fg:x="11222" fg:w="126"/><text x="28.9640%" y="351.50"></text></g><g><title>[libcrypto.so.3] (188 samples, 0.48%)</title><rect x="28.6372%" y="373" width="0.4810%" height="15" fill="rgb(233,39,42)" fg:x="11192" fg:w="188"/><text x="28.8872%" y="383.50"></text></g><g><title>[libcrypto.so.3] (32 samples, 0.08%)</title><rect x="29.0364%" y="357" width="0.0819%" height="15" fill="rgb(238,110,33)" fg:x="11348" fg:w="32"/><text x="29.2864%" y="367.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (1,141 samples, 2.92%)</title><rect x="26.2013%" y="437" width="2.9195%" height="15" fill="rgb(233,195,10)" fg:x="10240" fg:w="1141"/><text x="26.4513%" y="447.50">zs..</text></g><g><title>EVP_CipherInit_ex (1,141 samples, 2.92%)</title><rect x="26.2013%" y="421" width="2.9195%" height="15" fill="rgb(254,105,3)" fg:x="10240" fg:w="1141"/><text x="26.4513%" y="431.50">EV..</text></g><g><title>[libcrypto.so.3] (1,141 samples, 2.92%)</title><rect x="26.2013%" y="405" width="2.9195%" height="15" fill="rgb(221,225,9)" fg:x="10240" fg:w="1141"/><text x="26.4513%" y="415.50">[l..</text></g><g><title>[libcrypto.so.3] (224 samples, 0.57%)</title><rect x="28.5477%" y="389" width="0.5732%" height="15" fill="rgb(224,227,45)" fg:x="11157" fg:w="224"/><text x="28.7977%" y="399.50"></text></g><g><title>malloc (12 samples, 0.03%)</title><rect x="29.1311%" y="405" width="0.0307%" height="15" fill="rgb(229,198,43)" fg:x="11385" fg:w="12"/><text x="29.3811%" y="415.50"></text></g><g><title>CRYPTO_zalloc (17 samples, 0.04%)</title><rect x="29.1208%" y="421" width="0.0435%" height="15" fill="rgb(206,209,35)" fg:x="11381" fg:w="17"/><text x="29.3708%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (1,226 samples, 3.14%)</title><rect x="26.0350%" y="453" width="3.1370%" height="15" fill="rgb(245,195,53)" fg:x="10175" fg:w="1226"/><text x="26.2850%" y="463.50">&lt;zs..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::new (20 samples, 0.05%)</title><rect x="29.1208%" y="437" width="0.0512%" height="15" fill="rgb(240,92,26)" fg:x="11381" fg:w="20"/><text x="29.3708%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::Index&lt;I&gt; for [T]&gt;::index (6 samples, 0.02%)</title><rect x="29.1797%" y="453" width="0.0154%" height="15" fill="rgb(207,40,23)" fg:x="11404" fg:w="6"/><text x="29.4297%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index (6 samples, 0.02%)</title><rect x="29.1797%" y="437" width="0.0154%" height="15" fill="rgb(223,111,35)" fg:x="11404" fg:w="6"/><text x="29.4297%" y="447.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (5 samples, 0.01%)</title><rect x="29.1822%" y="421" width="0.0128%" height="15" fill="rgb(229,147,28)" fg:x="11405" fg:w="5"/><text x="29.4322%" y="431.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (5 samples, 0.01%)</title><rect x="29.1822%" y="405" width="0.0128%" height="15" fill="rgb(211,29,28)" fg:x="11405" fg:w="5"/><text x="29.4322%" y="415.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::add (4 samples, 0.01%)</title><rect x="29.1848%" y="389" width="0.0102%" height="15" fill="rgb(228,72,33)" fg:x="11406" fg:w="4"/><text x="29.4348%" y="399.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::offset (4 samples, 0.01%)</title><rect x="29.1848%" y="373" width="0.0102%" height="15" fill="rgb(205,214,31)" fg:x="11406" fg:w="4"/><text x="29.4348%" y="383.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (4 samples, 0.01%)</title><rect x="29.1950%" y="437" width="0.0102%" height="15" fill="rgb(224,111,15)" fg:x="11410" fg:w="4"/><text x="29.4450%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (5 samples, 0.01%)</title><rect x="29.1950%" y="453" width="0.0128%" height="15" fill="rgb(253,21,26)" fg:x="11410" fg:w="5"/><text x="29.4450%" y="463.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (232 samples, 0.59%)</title><rect x="29.2078%" y="453" width="0.5936%" height="15" fill="rgb(245,139,43)" fg:x="11415" fg:w="232"/><text x="29.4578%" y="463.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (232 samples, 0.59%)</title><rect x="29.2078%" y="437" width="0.5936%" height="15" fill="rgb(252,170,7)" fg:x="11415" fg:w="232"/><text x="29.4578%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (230 samples, 0.59%)</title><rect x="29.2129%" y="421" width="0.5885%" height="15" fill="rgb(231,118,14)" fg:x="11417" fg:w="230"/><text x="29.4629%" y="431.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (228 samples, 0.58%)</title><rect x="29.2181%" y="405" width="0.5834%" height="15" fill="rgb(238,83,0)" fg:x="11419" fg:w="228"/><text x="29.4681%" y="415.50"></text></g><g><title>[libc.so.6] (227 samples, 0.58%)</title><rect x="29.2206%" y="389" width="0.5808%" height="15" fill="rgb(221,39,39)" fg:x="11420" fg:w="227"/><text x="29.4706%" y="399.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::update (27 samples, 0.07%)</title><rect x="29.8014%" y="453" width="0.0691%" height="15" fill="rgb(222,119,46)" fg:x="11647" fg:w="27"/><text x="30.0514%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_max (26 samples, 0.07%)</title><rect x="29.8040%" y="437" width="0.0665%" height="15" fill="rgb(222,165,49)" fg:x="11648" fg:w="26"/><text x="30.0540%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_umax (26 samples, 0.07%)</title><rect x="29.8040%" y="421" width="0.0665%" height="15" fill="rgb(219,113,52)" fg:x="11648" fg:w="26"/><text x="30.0540%" y="431.50"></text></g><g><title>zssp::zeta::receive_payload_in_place (6,190 samples, 15.84%)</title><rect x="14.0346%" y="469" width="15.8385%" height="15" fill="rgb(214,7,15)" fg:x="5485" fg:w="6190"/><text x="14.2846%" y="479.50">zssp::zeta::receive_payl..</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8,570 samples, 21.93%)</title><rect x="8.1112%" y="485" width="21.9283%" height="15" fill="rgb(235,32,4)" fg:x="3170" fg:w="8570"/><text x="8.3612%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::receive</text></g><g><title>zssp::zssp::parse_fragment_header (65 samples, 0.17%)</title><rect x="29.8731%" y="469" width="0.1663%" height="15" fill="rgb(238,90,54)" fg:x="11675" fg:w="65"/><text x="30.1231%" y="479.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (4 samples, 0.01%)</title><rect x="30.0292%" y="453" width="0.0102%" height="15" fill="rgb(213,208,19)" fg:x="11736" fg:w="4"/><text x="30.2792%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (4 samples, 0.01%)</title><rect x="30.0292%" y="437" width="0.0102%" height="15" fill="rgb(233,156,4)" fg:x="11736" fg:w="4"/><text x="30.2792%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (56 samples, 0.14%)</title><rect x="30.1162%" y="437" width="0.1433%" height="15" fill="rgb(207,194,5)" fg:x="11770" fg:w="56"/><text x="30.3662%" y="447.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (56 samples, 0.14%)</title><rect x="30.1162%" y="421" width="0.1433%" height="15" fill="rgb(206,111,30)" fg:x="11770" fg:w="56"/><text x="30.3662%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (55 samples, 0.14%)</title><rect x="30.1187%" y="405" width="0.1407%" height="15" fill="rgb(243,70,54)" fg:x="11771" fg:w="55"/><text x="30.3687%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (52 samples, 0.13%)</title><rect x="30.1264%" y="389" width="0.1331%" height="15" fill="rgb(242,28,8)" fg:x="11774" fg:w="52"/><text x="30.3764%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_swap (52 samples, 0.13%)</title><rect x="30.1264%" y="373" width="0.1331%" height="15" fill="rgb(219,106,18)" fg:x="11774" fg:w="52"/><text x="30.3764%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (64 samples, 0.16%)</title><rect x="30.2595%" y="437" width="0.1638%" height="15" fill="rgb(244,222,10)" fg:x="11826" fg:w="64"/><text x="30.5095%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (61 samples, 0.16%)</title><rect x="30.2671%" y="421" width="0.1561%" height="15" fill="rgb(236,179,52)" fg:x="11829" fg:w="61"/><text x="30.5171%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (55 samples, 0.14%)</title><rect x="30.2825%" y="405" width="0.1407%" height="15" fill="rgb(213,23,39)" fg:x="11835" fg:w="55"/><text x="30.5325%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (55 samples, 0.14%)</title><rect x="30.2825%" y="389" width="0.1407%" height="15" fill="rgb(238,48,10)" fg:x="11835" fg:w="55"/><text x="30.5325%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (314 samples, 0.80%)</title><rect x="30.1008%" y="453" width="0.8034%" height="15" fill="rgb(251,196,23)" fg:x="11764" fg:w="314"/><text x="30.3508%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (188 samples, 0.48%)</title><rect x="30.4232%" y="437" width="0.4810%" height="15" fill="rgb(250,152,24)" fg:x="11890" fg:w="188"/><text x="30.6732%" y="447.50"></text></g><g><title>EVP_EncryptUpdate (183 samples, 0.47%)</title><rect x="30.4360%" y="421" width="0.4682%" height="15" fill="rgb(209,150,17)" fg:x="11895" fg:w="183"/><text x="30.6860%" y="431.50"></text></g><g><title>[libcrypto.so.3] (148 samples, 0.38%)</title><rect x="30.5256%" y="405" width="0.3787%" height="15" fill="rgb(234,202,34)" fg:x="11930" fg:w="148"/><text x="30.7756%" y="415.50"></text></g><g><title>[libcrypto.so.3] (106 samples, 0.27%)</title><rect x="30.6330%" y="389" width="0.2712%" height="15" fill="rgb(253,148,53)" fg:x="11972" fg:w="106"/><text x="30.8830%" y="399.50"></text></g><g><title>[libcrypto.so.3] (96 samples, 0.25%)</title><rect x="30.6586%" y="373" width="0.2456%" height="15" fill="rgb(218,129,16)" fg:x="11982" fg:w="96"/><text x="30.9086%" y="383.50"></text></g><g><title>CRYPTO_gcm128_encrypt (250 samples, 0.64%)</title><rect x="31.2139%" y="357" width="0.6397%" height="15" fill="rgb(216,85,19)" fg:x="12199" fg:w="250"/><text x="31.4639%" y="367.50"></text></g><g><title>[libcrypto.so.3] (143 samples, 0.37%)</title><rect x="31.4876%" y="341" width="0.3659%" height="15" fill="rgb(235,228,7)" fg:x="12306" fg:w="143"/><text x="31.7376%" y="351.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (415 samples, 1.06%)</title><rect x="31.8535%" y="357" width="1.0619%" height="15" fill="rgb(245,175,0)" fg:x="12449" fg:w="415"/><text x="32.1035%" y="367.50"></text></g><g><title>[libcrypto.so.3] (319 samples, 0.82%)</title><rect x="32.0992%" y="341" width="0.8162%" height="15" fill="rgb(208,168,36)" fg:x="12545" fg:w="319"/><text x="32.3492%" y="351.50"></text></g><g><title>[libcrypto.so.3] (28 samples, 0.07%)</title><rect x="32.8438%" y="325" width="0.0716%" height="15" fill="rgb(246,171,24)" fg:x="12836" fg:w="28"/><text x="33.0938%" y="335.50"></text></g><g><title>[libcrypto.so.3] (19 samples, 0.05%)</title><rect x="32.9180%" y="341" width="0.0486%" height="15" fill="rgb(215,142,24)" fg:x="12865" fg:w="19"/><text x="33.1680%" y="351.50"></text></g><g><title>CRYPTO_gcm128_setiv (25 samples, 0.06%)</title><rect x="32.9154%" y="357" width="0.0640%" height="15" fill="rgb(250,187,7)" fg:x="12864" fg:w="25"/><text x="33.1654%" y="367.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="32.9666%" y="341" width="0.0128%" height="15" fill="rgb(228,66,33)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="32.9666%" y="325" width="0.0128%" height="15" fill="rgb(234,215,21)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="335.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="32.9666%" y="309" width="0.0128%" height="15" fill="rgb(222,191,20)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="32.9666%" y="293" width="0.0128%" height="15" fill="rgb(245,79,54)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="32.9666%" y="277" width="0.0128%" height="15" fill="rgb(240,10,37)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="32.9666%" y="261" width="0.0128%" height="15" fill="rgb(214,192,32)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="32.9666%" y="245" width="0.0128%" height="15" fill="rgb(209,36,54)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="32.9666%" y="229" width="0.0128%" height="15" fill="rgb(220,10,11)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="239.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="32.9666%" y="213" width="0.0128%" height="15" fill="rgb(221,106,17)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="32.9666%" y="197" width="0.0128%" height="15" fill="rgb(251,142,44)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="207.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="32.9666%" y="181" width="0.0128%" height="15" fill="rgb(238,13,15)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="191.50"></text></g><g><title>perf_ctx_enable (18 samples, 0.05%)</title><rect x="39.3429%" y="165" width="0.0461%" height="15" fill="rgb(208,107,27)" fg:x="15376" fg:w="18"/><text x="39.5929%" y="175.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (3,317 samples, 8.49%)</title><rect x="30.9043%" y="453" width="8.4873%" height="15" fill="rgb(205,136,37)" fg:x="12078" fg:w="3317"/><text x="31.1543%" y="463.50">&lt;zssp::crypt..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (3,311 samples, 8.47%)</title><rect x="30.9196%" y="437" width="8.4719%" height="15" fill="rgb(250,205,27)" fg:x="12084" fg:w="3311"/><text x="31.1696%" y="447.50">zssp::crypto..</text></g><g><title>EVP_EncryptUpdate (3,309 samples, 8.47%)</title><rect x="30.9247%" y="421" width="8.4668%" height="15" fill="rgb(210,80,43)" fg:x="12086" fg:w="3309"/><text x="31.1747%" y="431.50">EVP_EncryptU..</text></g><g><title>[libcrypto.so.3] (3,257 samples, 8.33%)</title><rect x="31.0578%" y="405" width="8.3338%" height="15" fill="rgb(247,160,36)" fg:x="12138" fg:w="3257"/><text x="31.3078%" y="415.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,255 samples, 8.33%)</title><rect x="31.0629%" y="389" width="8.3286%" height="15" fill="rgb(234,13,49)" fg:x="12140" fg:w="3255"/><text x="31.3129%" y="399.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,235 samples, 8.28%)</title><rect x="31.1141%" y="373" width="8.2775%" height="15" fill="rgb(234,122,0)" fg:x="12160" fg:w="3235"/><text x="31.3641%" y="383.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (2,506 samples, 6.41%)</title><rect x="32.9794%" y="357" width="6.4122%" height="15" fill="rgb(207,146,38)" fg:x="12889" fg:w="2506"/><text x="33.2294%" y="367.50">[libcryp..</text></g><g><title>[libcrypto.so.3] (2,299 samples, 5.88%)</title><rect x="33.5090%" y="341" width="5.8825%" height="15" fill="rgb(207,177,25)" fg:x="13096" fg:w="2299"/><text x="33.7590%" y="351.50">[libcry..</text></g><g><title>asm_sysvec_reschedule_ipi (20 samples, 0.05%)</title><rect x="39.3404%" y="325" width="0.0512%" height="15" fill="rgb(211,178,42)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (20 samples, 0.05%)</title><rect x="39.3404%" y="309" width="0.0512%" height="15" fill="rgb(230,69,54)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="319.50"></text></g><g><title>irqentry_exit (20 samples, 0.05%)</title><rect x="39.3404%" y="293" width="0.0512%" height="15" fill="rgb(214,135,41)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (20 samples, 0.05%)</title><rect x="39.3404%" y="277" width="0.0512%" height="15" fill="rgb(237,67,25)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (20 samples, 0.05%)</title><rect x="39.3404%" y="261" width="0.0512%" height="15" fill="rgb(222,189,50)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (20 samples, 0.05%)</title><rect x="39.3404%" y="245" width="0.0512%" height="15" fill="rgb(245,148,34)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="255.50"></text></g><g><title>schedule (19 samples, 0.05%)</title><rect x="39.3429%" y="229" width="0.0486%" height="15" fill="rgb(222,29,6)" fg:x="15376" fg:w="19"/><text x="39.5929%" y="239.50"></text></g><g><title>__schedule (19 samples, 0.05%)</title><rect x="39.3429%" y="213" width="0.0486%" height="15" fill="rgb(221,189,43)" fg:x="15376" fg:w="19"/><text x="39.5929%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (19 samples, 0.05%)</title><rect x="39.3429%" y="197" width="0.0486%" height="15" fill="rgb(207,36,27)" fg:x="15376" fg:w="19"/><text x="39.5929%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (19 samples, 0.05%)</title><rect x="39.3429%" y="181" width="0.0486%" height="15" fill="rgb(217,90,24)" fg:x="15376" fg:w="19"/><text x="39.5929%" y="191.50"></text></g><g><title>CRYPTO_clear_free (107 samples, 0.27%)</title><rect x="39.4402%" y="357" width="0.2738%" height="15" fill="rgb(224,66,35)" fg:x="15414" fg:w="107"/><text x="39.6902%" y="367.50"></text></g><g><title>OPENSSL_cleanse (103 samples, 0.26%)</title><rect x="39.4504%" y="341" width="0.2635%" height="15" fill="rgb(221,13,50)" fg:x="15418" fg:w="103"/><text x="39.7004%" y="351.50"></text></g><g><title>EVP_CIPHER_free (30 samples, 0.08%)</title><rect x="39.7139%" y="357" width="0.0768%" height="15" fill="rgb(236,68,49)" fg:x="15521" fg:w="30"/><text x="39.9639%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_free (206 samples, 0.53%)</title><rect x="39.3967%" y="389" width="0.5271%" height="15" fill="rgb(229,146,28)" fg:x="15397" fg:w="206"/><text x="39.6467%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_reset (205 samples, 0.52%)</title><rect x="39.3992%" y="373" width="0.5245%" height="15" fill="rgb(225,31,38)" fg:x="15398" fg:w="205"/><text x="39.6492%" y="383.50"></text></g><g><title>cfree (52 samples, 0.13%)</title><rect x="39.7907%" y="357" width="0.1331%" height="15" fill="rgb(250,208,3)" fg:x="15551" fg:w="52"/><text x="40.0407%" y="367.50"></text></g><g><title>[libc.so.6] (11 samples, 0.03%)</title><rect x="39.8956%" y="341" width="0.0281%" height="15" fill="rgb(246,54,23)" fg:x="15592" fg:w="11"/><text x="40.1456%" y="351.50"></text></g><g><title>cfree (11 samples, 0.03%)</title><rect x="39.9238%" y="389" width="0.0281%" height="15" fill="rgb(243,76,11)" fg:x="15603" fg:w="11"/><text x="40.1738%" y="399.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="39.9391%" y="373" width="0.0128%" height="15" fill="rgb(245,21,50)" fg:x="15609" fg:w="5"/><text x="40.1891%" y="383.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc&gt; (220 samples, 0.56%)</title><rect x="39.3915%" y="437" width="0.5629%" height="15" fill="rgb(228,9,43)" fg:x="15395" fg:w="220"/><text x="39.6415%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::CipherCtx&gt; (220 samples, 0.56%)</title><rect x="39.3915%" y="421" width="0.5629%" height="15" fill="rgb(208,100,47)" fg:x="15395" fg:w="220"/><text x="39.6415%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::CipherCtx as core::ops::drop::Drop&gt;::drop (220 samples, 0.56%)</title><rect x="39.3915%" y="405" width="0.5629%" height="15" fill="rgb(232,26,8)" fg:x="15395" fg:w="220"/><text x="39.6415%" y="415.50"></text></g><g><title>[libcrypto.so.3] (15 samples, 0.04%)</title><rect x="40.0338%" y="325" width="0.0384%" height="15" fill="rgb(216,166,38)" fg:x="15646" fg:w="15"/><text x="40.2838%" y="335.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (47 samples, 0.12%)</title><rect x="39.9545%" y="437" width="0.1203%" height="15" fill="rgb(251,202,51)" fg:x="15615" fg:w="47"/><text x="40.2045%" y="447.50"></text></g><g><title>EVP_EncryptFinal_ex (46 samples, 0.12%)</title><rect x="39.9570%" y="421" width="0.1177%" height="15" fill="rgb(254,216,34)" fg:x="15616" fg:w="46"/><text x="40.2070%" y="431.50"></text></g><g><title>[libcrypto.so.3] (33 samples, 0.08%)</title><rect x="39.9903%" y="405" width="0.0844%" height="15" fill="rgb(251,32,27)" fg:x="15629" fg:w="33"/><text x="40.2403%" y="415.50"></text></g><g><title>[libcrypto.so.3] (33 samples, 0.08%)</title><rect x="39.9903%" y="389" width="0.0844%" height="15" fill="rgb(208,127,28)" fg:x="15629" fg:w="33"/><text x="40.2403%" y="399.50"></text></g><g><title>[libcrypto.so.3] (29 samples, 0.07%)</title><rect x="40.0005%" y="373" width="0.0742%" height="15" fill="rgb(224,137,22)" fg:x="15633" fg:w="29"/><text x="40.2505%" y="383.50"></text></g><g><title>CRYPTO_gcm128_tag (29 samples, 0.07%)</title><rect x="40.0005%" y="357" width="0.0742%" height="15" fill="rgb(254,70,32)" fg:x="15633" fg:w="29"/><text x="40.2505%" y="367.50"></text></g><g><title>CRYPTO_gcm128_finish (22 samples, 0.06%)</title><rect x="40.0184%" y="341" width="0.0563%" height="15" fill="rgb(229,75,37)" fg:x="15640" fg:w="22"/><text x="40.2684%" y="351.50"></text></g><g><title>[libc.so.6] (32 samples, 0.08%)</title><rect x="40.2001%" y="373" width="0.0819%" height="15" fill="rgb(252,64,23)" fg:x="15711" fg:w="32"/><text x="40.4501%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (53 samples, 0.14%)</title><rect x="40.1592%" y="389" width="0.1356%" height="15" fill="rgb(232,162,48)" fg:x="15695" fg:w="53"/><text x="40.4092%" y="399.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="40.2820%" y="373" width="0.0128%" height="15" fill="rgb(246,160,12)" fg:x="15743" fg:w="5"/><text x="40.5320%" y="383.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::finish (358 samples, 0.92%)</title><rect x="39.3915%" y="453" width="0.9160%" height="15" fill="rgb(247,166,0)" fg:x="15395" fg:w="358"/><text x="39.6415%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::get_tag (91 samples, 0.23%)</title><rect x="40.0747%" y="437" width="0.2328%" height="15" fill="rgb(249,219,21)" fg:x="15662" fg:w="91"/><text x="40.3247%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (91 samples, 0.23%)</title><rect x="40.0747%" y="421" width="0.2328%" height="15" fill="rgb(205,209,3)" fg:x="15662" fg:w="91"/><text x="40.3247%" y="431.50"></text></g><g><title>[libcrypto.so.3] (68 samples, 0.17%)</title><rect x="40.1336%" y="405" width="0.1740%" height="15" fill="rgb(243,44,1)" fg:x="15685" fg:w="68"/><text x="40.3836%" y="415.50"></text></g><g><title>OSSL_PARAM_set_octet_string (5 samples, 0.01%)</title><rect x="40.2948%" y="389" width="0.0128%" height="15" fill="rgb(206,159,16)" fg:x="15748" fg:w="5"/><text x="40.5448%" y="399.50"></text></g><g><title>[libc.so.6] (12 samples, 0.03%)</title><rect x="40.4355%" y="389" width="0.0307%" height="15" fill="rgb(244,77,30)" fg:x="15803" fg:w="12"/><text x="40.6855%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (64 samples, 0.16%)</title><rect x="40.3127%" y="437" width="0.1638%" height="15" fill="rgb(218,69,12)" fg:x="15755" fg:w="64"/><text x="40.5627%" y="447.50"></text></g><g><title>[libcrypto.so.3] (38 samples, 0.10%)</title><rect x="40.3792%" y="421" width="0.0972%" height="15" fill="rgb(212,87,7)" fg:x="15781" fg:w="38"/><text x="40.6292%" y="431.50"></text></g><g><title>OSSL_PARAM_locate (32 samples, 0.08%)</title><rect x="40.3946%" y="405" width="0.0819%" height="15" fill="rgb(245,114,25)" fg:x="15787" fg:w="32"/><text x="40.6446%" y="415.50"></text></g><g><title>strcmp@plt (4 samples, 0.01%)</title><rect x="40.4662%" y="389" width="0.0102%" height="15" fill="rgb(210,61,42)" fg:x="15815" fg:w="4"/><text x="40.7162%" y="399.50"></text></g><g><title>[libc.so.6] (17 samples, 0.04%)</title><rect x="40.6786%" y="341" width="0.0435%" height="15" fill="rgb(211,52,33)" fg:x="15898" fg:w="17"/><text x="40.9286%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (40 samples, 0.10%)</title><rect x="40.6325%" y="357" width="0.1023%" height="15" fill="rgb(234,58,33)" fg:x="15880" fg:w="40"/><text x="40.8825%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="40.7221%" y="341" width="0.0128%" height="15" fill="rgb(220,115,36)" fg:x="15915" fg:w="5"/><text x="40.9721%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (79 samples, 0.20%)</title><rect x="40.5353%" y="389" width="0.2021%" height="15" fill="rgb(243,153,54)" fg:x="15842" fg:w="79"/><text x="40.7853%" y="399.50"></text></g><g><title>[libcrypto.so.3] (55 samples, 0.14%)</title><rect x="40.5967%" y="373" width="0.1407%" height="15" fill="rgb(251,47,18)" fg:x="15866" fg:w="55"/><text x="40.8467%" y="383.50"></text></g><g><title>[libc.so.6] (20 samples, 0.05%)</title><rect x="40.8347%" y="341" width="0.0512%" height="15" fill="rgb(242,102,42)" fg:x="15959" fg:w="20"/><text x="41.0847%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (37 samples, 0.09%)</title><rect x="40.7988%" y="357" width="0.0947%" height="15" fill="rgb(234,31,38)" fg:x="15945" fg:w="37"/><text x="41.0488%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_key_length (63 samples, 0.16%)</title><rect x="40.7374%" y="389" width="0.1612%" height="15" fill="rgb(221,117,51)" fg:x="15921" fg:w="63"/><text x="40.9874%" y="399.50"></text></g><g><title>[libcrypto.so.3] (54 samples, 0.14%)</title><rect x="40.7605%" y="373" width="0.1382%" height="15" fill="rgb(212,20,18)" fg:x="15930" fg:w="54"/><text x="41.0105%" y="383.50"></text></g><g><title>pthread_rwlock_rdlock (130 samples, 0.33%)</title><rect x="40.9498%" y="325" width="0.3326%" height="15" fill="rgb(245,133,36)" fg:x="16004" fg:w="130"/><text x="41.1998%" y="335.50"></text></g><g><title>CRYPTO_THREAD_read_lock (136 samples, 0.35%)</title><rect x="40.9421%" y="341" width="0.3480%" height="15" fill="rgb(212,6,19)" fg:x="16001" fg:w="136"/><text x="41.1921%" y="351.50"></text></g><g><title>pthread_rwlock_unlock (73 samples, 0.19%)</title><rect x="41.3003%" y="325" width="0.1868%" height="15" fill="rgb(218,1,36)" fg:x="16141" fg:w="73"/><text x="41.5503%" y="335.50"></text></g><g><title>CRYPTO_THREAD_unlock (82 samples, 0.21%)</title><rect x="41.2901%" y="341" width="0.2098%" height="15" fill="rgb(246,84,54)" fg:x="16137" fg:w="82"/><text x="41.5401%" y="351.50"></text></g><g><title>pthread_rwlock_unlock@plt (5 samples, 0.01%)</title><rect x="41.4871%" y="325" width="0.0128%" height="15" fill="rgb(242,110,6)" fg:x="16214" fg:w="5"/><text x="41.7371%" y="335.50"></text></g><g><title>EVP_CIPHER_up_ref (24 samples, 0.06%)</title><rect x="41.5050%" y="341" width="0.0614%" height="15" fill="rgb(214,47,5)" fg:x="16221" fg:w="24"/><text x="41.7550%" y="351.50"></text></g><g><title>OPENSSL_LH_retrieve (75 samples, 0.19%)</title><rect x="41.5665%" y="341" width="0.1919%" height="15" fill="rgb(218,159,25)" fg:x="16245" fg:w="75"/><text x="41.8165%" y="351.50"></text></g><g><title>[libcrypto.so.3] (56 samples, 0.14%)</title><rect x="41.6151%" y="325" width="0.1433%" height="15" fill="rgb(215,211,28)" fg:x="16264" fg:w="56"/><text x="41.8651%" y="335.50"></text></g><g><title>[libcrypto.so.3] (5 samples, 0.01%)</title><rect x="41.7456%" y="309" width="0.0128%" height="15" fill="rgb(238,59,32)" fg:x="16315" fg:w="5"/><text x="41.9956%" y="319.50"></text></g><g><title>pthread_rwlock_rdlock (38 samples, 0.10%)</title><rect x="41.7839%" y="309" width="0.0972%" height="15" fill="rgb(226,82,3)" fg:x="16330" fg:w="38"/><text x="42.0339%" y="319.50"></text></g><g><title>CRYPTO_THREAD_read_lock (40 samples, 0.10%)</title><rect x="41.7839%" y="325" width="0.1023%" height="15" fill="rgb(240,164,32)" fg:x="16330" fg:w="40"/><text x="42.0339%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (43 samples, 0.11%)</title><rect x="41.8914%" y="309" width="0.1100%" height="15" fill="rgb(232,46,7)" fg:x="16372" fg:w="43"/><text x="42.1414%" y="319.50"></text></g><g><title>CRYPTO_THREAD_unlock (45 samples, 0.12%)</title><rect x="41.8914%" y="325" width="0.1151%" height="15" fill="rgb(229,129,53)" fg:x="16372" fg:w="45"/><text x="42.1414%" y="335.50"></text></g><g><title>OPENSSL_strnlen (5 samples, 0.01%)</title><rect x="42.0168%" y="309" width="0.0128%" height="15" fill="rgb(234,188,29)" fg:x="16421" fg:w="5"/><text x="42.2668%" y="319.50"></text></g><g><title>CRYPTO_strndup (10 samples, 0.03%)</title><rect x="42.0168%" y="325" width="0.0256%" height="15" fill="rgb(246,141,4)" fg:x="16421" fg:w="10"/><text x="42.2668%" y="335.50"></text></g><g><title>malloc (5 samples, 0.01%)</title><rect x="42.0296%" y="309" width="0.0128%" height="15" fill="rgb(229,23,39)" fg:x="16426" fg:w="5"/><text x="42.2796%" y="319.50"></text></g><g><title>OPENSSL_strcasecmp (41 samples, 0.10%)</title><rect x="42.2010%" y="293" width="0.1049%" height="15" fill="rgb(206,12,3)" fg:x="16493" fg:w="41"/><text x="42.4510%" y="303.50"></text></g><g><title>OPENSSL_LH_retrieve (132 samples, 0.34%)</title><rect x="42.0424%" y="325" width="0.3378%" height="15" fill="rgb(252,226,20)" fg:x="16431" fg:w="132"/><text x="42.2924%" y="335.50"></text></g><g><title>[libcrypto.so.3] (118 samples, 0.30%)</title><rect x="42.0782%" y="309" width="0.3019%" height="15" fill="rgb(216,123,35)" fg:x="16445" fg:w="118"/><text x="42.3282%" y="319.50"></text></g><g><title>[libcrypto.so.3] (29 samples, 0.07%)</title><rect x="42.3059%" y="293" width="0.0742%" height="15" fill="rgb(212,68,40)" fg:x="16534" fg:w="29"/><text x="42.5559%" y="303.50"></text></g><g><title>cfree (19 samples, 0.05%)</title><rect x="42.3801%" y="325" width="0.0486%" height="15" fill="rgb(254,125,32)" fg:x="16563" fg:w="19"/><text x="42.6301%" y="335.50"></text></g><g><title>[libc.so.6] (7 samples, 0.02%)</title><rect x="42.4108%" y="309" width="0.0179%" height="15" fill="rgb(253,97,22)" fg:x="16575" fg:w="7"/><text x="42.6608%" y="319.50"></text></g><g><title>[libcrypto.so.3] (264 samples, 0.68%)</title><rect x="41.7584%" y="341" width="0.6755%" height="15" fill="rgb(241,101,14)" fg:x="16320" fg:w="264"/><text x="42.0084%" y="351.50"></text></g><g><title>EVP_CIPHER_fetch (603 samples, 1.54%)</title><rect x="40.8986%" y="389" width="1.5429%" height="15" fill="rgb(238,103,29)" fg:x="15984" fg:w="603"/><text x="41.1486%" y="399.50"></text></g><g><title>[libcrypto.so.3] (600 samples, 1.54%)</title><rect x="40.9063%" y="373" width="1.5352%" height="15" fill="rgb(233,195,47)" fg:x="15987" fg:w="600"/><text x="41.1563%" y="383.50"></text></g><g><title>[libcrypto.so.3] (594 samples, 1.52%)</title><rect x="40.9217%" y="357" width="1.5199%" height="15" fill="rgb(246,218,30)" fg:x="15993" fg:w="594"/><text x="41.1717%" y="367.50"></text></g><g><title>EVP_CIPHER_free (17 samples, 0.04%)</title><rect x="42.4415%" y="389" width="0.0435%" height="15" fill="rgb(219,145,47)" fg:x="16587" fg:w="17"/><text x="42.6915%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (20 samples, 0.05%)</title><rect x="42.4850%" y="389" width="0.0512%" height="15" fill="rgb(243,12,26)" fg:x="16604" fg:w="20"/><text x="42.7350%" y="399.50"></text></g><g><title>OBJ_nid2sn (6 samples, 0.02%)</title><rect x="42.5362%" y="389" width="0.0154%" height="15" fill="rgb(214,87,16)" fg:x="16624" fg:w="6"/><text x="42.7862%" y="399.50"></text></g><g><title>malloc (8 samples, 0.02%)</title><rect x="42.5874%" y="357" width="0.0205%" height="15" fill="rgb(208,99,42)" fg:x="16644" fg:w="8"/><text x="42.8374%" y="367.50"></text></g><g><title>CRYPTO_zalloc (14 samples, 0.04%)</title><rect x="42.5771%" y="373" width="0.0358%" height="15" fill="rgb(253,99,2)" fg:x="16640" fg:w="14"/><text x="42.8271%" y="383.50"></text></g><g><title>OPENSSL_init_crypto (5 samples, 0.01%)</title><rect x="42.6130%" y="373" width="0.0128%" height="15" fill="rgb(220,168,23)" fg:x="16654" fg:w="5"/><text x="42.8630%" y="383.50"></text></g><g><title>CRYPTO_gcm128_init (161 samples, 0.41%)</title><rect x="42.6309%" y="357" width="0.4120%" height="15" fill="rgb(242,38,24)" fg:x="16661" fg:w="161"/><text x="42.8809%" y="367.50"></text></g><g><title>[libcrypto.so.3] (132 samples, 0.34%)</title><rect x="42.7051%" y="341" width="0.3378%" height="15" fill="rgb(225,182,9)" fg:x="16690" fg:w="132"/><text x="42.9551%" y="351.50"></text></g><g><title>[libcrypto.so.3] (201 samples, 0.51%)</title><rect x="42.6283%" y="373" width="0.5143%" height="15" fill="rgb(243,178,37)" fg:x="16660" fg:w="201"/><text x="42.8783%" y="383.50"></text></g><g><title>[libcrypto.so.3] (39 samples, 0.10%)</title><rect x="43.0428%" y="357" width="0.0998%" height="15" fill="rgb(232,139,19)" fg:x="16822" fg:w="39"/><text x="43.2928%" y="367.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (1,042 samples, 2.67%)</title><rect x="40.4790%" y="437" width="2.6662%" height="15" fill="rgb(225,201,24)" fg:x="15820" fg:w="1042"/><text x="40.7290%" y="447.50">zs..</text></g><g><title>EVP_CipherInit_ex (1,042 samples, 2.67%)</title><rect x="40.4790%" y="421" width="2.6662%" height="15" fill="rgb(221,47,46)" fg:x="15820" fg:w="1042"/><text x="40.7290%" y="431.50">EV..</text></g><g><title>[libcrypto.so.3] (1,042 samples, 2.67%)</title><rect x="40.4790%" y="405" width="2.6662%" height="15" fill="rgb(249,23,13)" fg:x="15820" fg:w="1042"/><text x="40.7290%" y="415.50">[l..</text></g><g><title>[libcrypto.so.3] (232 samples, 0.59%)</title><rect x="42.5516%" y="389" width="0.5936%" height="15" fill="rgb(219,9,5)" fg:x="16630" fg:w="232"/><text x="42.8016%" y="399.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="43.1477%" y="405" width="0.0102%" height="15" fill="rgb(254,171,16)" fg:x="16863" fg:w="4"/><text x="43.3977%" y="415.50"></text></g><g><title>malloc (9 samples, 0.02%)</title><rect x="43.1580%" y="405" width="0.0230%" height="15" fill="rgb(230,171,20)" fg:x="16867" fg:w="9"/><text x="43.4080%" y="415.50"></text></g><g><title>CRYPTO_zalloc (15 samples, 0.04%)</title><rect x="43.1452%" y="421" width="0.0384%" height="15" fill="rgb(210,71,41)" fg:x="16862" fg:w="15"/><text x="43.3952%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (1,125 samples, 2.88%)</title><rect x="40.3076%" y="453" width="2.8786%" height="15" fill="rgb(206,173,20)" fg:x="15753" fg:w="1125"/><text x="40.5576%" y="463.50">&lt;z..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::new (16 samples, 0.04%)</title><rect x="43.1452%" y="437" width="0.0409%" height="15" fill="rgb(233,88,34)" fg:x="16862" fg:w="16"/><text x="43.3952%" y="447.50"></text></g><g><title>__rdl_alloc (9 samples, 0.02%)</title><rect x="43.1912%" y="277" width="0.0230%" height="15" fill="rgb(223,209,46)" fg:x="16880" fg:w="9"/><text x="43.4412%" y="287.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::alloc (9 samples, 0.02%)</title><rect x="43.1912%" y="261" width="0.0230%" height="15" fill="rgb(250,43,18)" fg:x="16880" fg:w="9"/><text x="43.4412%" y="271.50"></text></g><g><title>[libc.so.6] (54 samples, 0.14%)</title><rect x="47.1240%" y="245" width="0.1382%" height="15" fill="rgb(208,13,10)" fg:x="18417" fg:w="54"/><text x="47.3740%" y="255.50"></text></g><g><title>[libc.so.6] (925 samples, 2.37%)</title><rect x="44.8979%" y="261" width="2.3668%" height="15" fill="rgb(212,200,36)" fg:x="17547" fg:w="925"/><text x="45.1479%" y="271.50">[l..</text></g><g><title>__entry_text_start (4 samples, 0.01%)</title><rect x="47.3057%" y="245" width="0.0102%" height="15" fill="rgb(225,90,30)" fg:x="18488" fg:w="4"/><text x="47.5557%" y="255.50"></text></g><g><title>__get_user_nocheck_4 (5 samples, 0.01%)</title><rect x="47.3338%" y="149" width="0.0128%" height="15" fill="rgb(236,182,39)" fg:x="18499" fg:w="5"/><text x="47.5838%" y="159.50"></text></g><g><title>futex_q_lock (5 samples, 0.01%)</title><rect x="47.3517%" y="149" width="0.0128%" height="15" fill="rgb(212,144,35)" fg:x="18506" fg:w="5"/><text x="47.6017%" y="159.50"></text></g><g><title>futex_q_unlock (6 samples, 0.02%)</title><rect x="47.3645%" y="149" width="0.0154%" height="15" fill="rgb(228,63,44)" fg:x="18511" fg:w="6"/><text x="47.6145%" y="159.50"></text></g><g><title>futex_wait (24 samples, 0.06%)</title><rect x="47.3210%" y="181" width="0.0614%" height="15" fill="rgb(228,109,6)" fg:x="18494" fg:w="24"/><text x="47.5710%" y="191.50"></text></g><g><title>futex_wait_setup (19 samples, 0.05%)</title><rect x="47.3338%" y="165" width="0.0486%" height="15" fill="rgb(238,117,24)" fg:x="18499" fg:w="19"/><text x="47.5838%" y="175.50"></text></g><g><title>__x64_sys_futex (26 samples, 0.07%)</title><rect x="47.3185%" y="213" width="0.0665%" height="15" fill="rgb(242,26,26)" fg:x="18493" fg:w="26"/><text x="47.5685%" y="223.50"></text></g><g><title>do_futex (26 samples, 0.07%)</title><rect x="47.3185%" y="197" width="0.0665%" height="15" fill="rgb(221,92,48)" fg:x="18493" fg:w="26"/><text x="47.5685%" y="207.50"></text></g><g><title>do_syscall_64 (31 samples, 0.08%)</title><rect x="47.3185%" y="229" width="0.0793%" height="15" fill="rgb(209,209,32)" fg:x="18493" fg:w="31"/><text x="47.5685%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (4 samples, 0.01%)</title><rect x="47.3875%" y="213" width="0.0102%" height="15" fill="rgb(221,70,22)" fg:x="18520" fg:w="4"/><text x="47.6375%" y="223.50"></text></g><g><title>__lll_lock_wait_private (53 samples, 0.14%)</title><rect x="47.2647%" y="261" width="0.1356%" height="15" fill="rgb(248,145,5)" fg:x="18472" fg:w="53"/><text x="47.5147%" y="271.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (33 samples, 0.08%)</title><rect x="47.3159%" y="245" width="0.0844%" height="15" fill="rgb(226,116,26)" fg:x="18492" fg:w="33"/><text x="47.5659%" y="255.50"></text></g><g><title>__entry_text_start (4 samples, 0.01%)</title><rect x="47.4157%" y="245" width="0.0102%" height="15" fill="rgb(244,5,17)" fg:x="18531" fg:w="4"/><text x="47.6657%" y="255.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="47.4310%" y="181" width="0.0102%" height="15" fill="rgb(252,159,33)" fg:x="18537" fg:w="4"/><text x="47.6810%" y="191.50"></text></g><g><title>futex_hash (4 samples, 0.01%)</title><rect x="47.4413%" y="181" width="0.0102%" height="15" fill="rgb(206,71,0)" fg:x="18541" fg:w="4"/><text x="47.6913%" y="191.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="47.5385%" y="165" width="0.0102%" height="15" fill="rgb(233,118,54)" fg:x="18579" fg:w="4"/><text x="47.7885%" y="175.50"></text></g><g><title>native_queued_spin_lock_slowpath (4 samples, 0.01%)</title><rect x="47.5385%" y="149" width="0.0102%" height="15" fill="rgb(234,83,48)" fg:x="18579" fg:w="4"/><text x="47.7885%" y="159.50"></text></g><g><title>futex_wake_mark (13 samples, 0.03%)</title><rect x="47.5487%" y="165" width="0.0333%" height="15" fill="rgb(228,3,54)" fg:x="18583" fg:w="13"/><text x="47.7987%" y="175.50"></text></g><g><title>preempt_schedule_thunk (5 samples, 0.01%)</title><rect x="47.6716%" y="133" width="0.0128%" height="15" fill="rgb(226,155,13)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="143.50"></text></g><g><title>preempt_schedule (5 samples, 0.01%)</title><rect x="47.6716%" y="117" width="0.0128%" height="15" fill="rgb(241,28,37)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="127.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="47.6716%" y="101" width="0.0128%" height="15" fill="rgb(233,93,10)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="111.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="47.6716%" y="85" width="0.0128%" height="15" fill="rgb(225,113,19)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="95.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="47.6716%" y="69" width="0.0128%" height="15" fill="rgb(241,2,18)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="79.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="47.6716%" y="53" width="0.0128%" height="15" fill="rgb(228,207,21)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="63.50"></text></g><g><title>__smp_call_single_queue (12 samples, 0.03%)</title><rect x="47.6997%" y="117" width="0.0307%" height="15" fill="rgb(213,211,35)" fg:x="18642" fg:w="12"/><text x="47.9497%" y="127.50"></text></g><g><title>native_send_call_func_single_ipi (9 samples, 0.02%)</title><rect x="47.7074%" y="101" width="0.0230%" height="15" fill="rgb(209,83,10)" fg:x="18645" fg:w="9"/><text x="47.9574%" y="111.50"></text></g><g><title>x2apic_send_IPI (9 samples, 0.02%)</title><rect x="47.7074%" y="85" width="0.0230%" height="15" fill="rgb(209,164,1)" fg:x="18645" fg:w="9"/><text x="47.9574%" y="95.50"></text></g><g><title>native_write_msr (6 samples, 0.02%)</title><rect x="47.7151%" y="69" width="0.0154%" height="15" fill="rgb(213,184,43)" fg:x="18648" fg:w="6"/><text x="47.9651%" y="79.50"></text></g><g><title>llist_add_batch (17 samples, 0.04%)</title><rect x="47.7304%" y="117" width="0.0435%" height="15" fill="rgb(231,61,34)" fg:x="18654" fg:w="17"/><text x="47.9804%" y="127.50"></text></g><g><title>do_futex (136 samples, 0.35%)</title><rect x="47.4310%" y="197" width="0.3480%" height="15" fill="rgb(235,75,3)" fg:x="18537" fg:w="136"/><text x="47.6810%" y="207.50"></text></g><g><title>futex_wake (128 samples, 0.33%)</title><rect x="47.4515%" y="181" width="0.3275%" height="15" fill="rgb(220,106,47)" fg:x="18545" fg:w="128"/><text x="47.7015%" y="191.50"></text></g><g><title>wake_up_q (75 samples, 0.19%)</title><rect x="47.5871%" y="165" width="0.1919%" height="15" fill="rgb(210,196,33)" fg:x="18598" fg:w="75"/><text x="47.8371%" y="175.50"></text></g><g><title>try_to_wake_up (66 samples, 0.17%)</title><rect x="47.6102%" y="149" width="0.1689%" height="15" fill="rgb(229,154,42)" fg:x="18607" fg:w="66"/><text x="47.8602%" y="159.50"></text></g><g><title>ttwu_queue_wakelist (36 samples, 0.09%)</title><rect x="47.6869%" y="133" width="0.0921%" height="15" fill="rgb(228,114,26)" fg:x="18637" fg:w="36"/><text x="47.9369%" y="143.50"></text></g><g><title>__x64_sys_futex (137 samples, 0.35%)</title><rect x="47.4310%" y="213" width="0.3505%" height="15" fill="rgb(208,144,1)" fg:x="18537" fg:w="137"/><text x="47.6810%" y="223.50"></text></g><g><title>do_syscall_64 (141 samples, 0.36%)</title><rect x="47.4310%" y="229" width="0.3608%" height="15" fill="rgb(239,112,37)" fg:x="18537" fg:w="141"/><text x="47.6810%" y="239.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (144 samples, 0.37%)</title><rect x="47.4259%" y="245" width="0.3685%" height="15" fill="rgb(210,96,50)" fg:x="18535" fg:w="144"/><text x="47.6759%" y="255.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (1,803 samples, 4.61%)</title><rect x="43.1861%" y="373" width="4.6134%" height="15" fill="rgb(222,178,2)" fg:x="16878" fg:w="1803"/><text x="43.4361%" y="383.50">alloc..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (1,803 samples, 4.61%)</title><rect x="43.1861%" y="357" width="4.6134%" height="15" fill="rgb(226,74,18)" fg:x="16878" fg:w="1803"/><text x="43.4361%" y="367.50">alloc..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (1,803 samples, 4.61%)</title><rect x="43.1861%" y="341" width="4.6134%" height="15" fill="rgb(225,67,54)" fg:x="16878" fg:w="1803"/><text x="43.4361%" y="351.50">alloc..</text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (1,801 samples, 4.61%)</title><rect x="43.1912%" y="325" width="4.6083%" height="15" fill="rgb(251,92,32)" fg:x="16880" fg:w="1801"/><text x="43.4412%" y="335.50">&lt;allo..</text></g><g><title>alloc::alloc::Global::alloc_impl (1,801 samples, 4.61%)</title><rect x="43.1912%" y="309" width="4.6083%" height="15" fill="rgb(228,149,22)" fg:x="16880" fg:w="1801"/><text x="43.4412%" y="319.50">alloc..</text></g><g><title>alloc::alloc::alloc (1,801 samples, 4.61%)</title><rect x="43.1912%" y="293" width="4.6083%" height="15" fill="rgb(243,54,13)" fg:x="16880" fg:w="1801"/><text x="43.4412%" y="303.50">alloc..</text></g><g><title>malloc (1,789 samples, 4.58%)</title><rect x="43.2219%" y="277" width="4.5776%" height="15" fill="rgb(243,180,28)" fg:x="16892" fg:w="1789"/><text x="43.4719%" y="287.50">malloc</text></g><g><title>__lll_lock_wake_private (156 samples, 0.40%)</title><rect x="47.4003%" y="261" width="0.3992%" height="15" fill="rgb(208,167,24)" fg:x="18525" fg:w="156"/><text x="47.6503%" y="271.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (2,000 samples, 5.12%)</title><rect x="43.1861%" y="437" width="5.1174%" height="15" fill="rgb(245,73,45)" fg:x="16878" fg:w="2000"/><text x="43.4361%" y="447.50">alloc:..</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (2,000 samples, 5.12%)</title><rect x="43.1861%" y="421" width="5.1174%" height="15" fill="rgb(237,203,48)" fg:x="16878" fg:w="2000"/><text x="43.4361%" y="431.50">alloc:..</text></g><g><title>alloc::slice::hack::to_vec (2,000 samples, 5.12%)</title><rect x="43.1861%" y="405" width="5.1174%" height="15" fill="rgb(211,197,16)" fg:x="16878" fg:w="2000"/><text x="43.4361%" y="415.50">alloc:..</text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (2,000 samples, 5.12%)</title><rect x="43.1861%" y="389" width="5.1174%" height="15" fill="rgb(243,99,51)" fg:x="16878" fg:w="2000"/><text x="43.4361%" y="399.50">&lt;T as ..</text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (197 samples, 0.50%)</title><rect x="47.7995%" y="373" width="0.5041%" height="15" fill="rgb(215,123,29)" fg:x="18681" fg:w="197"/><text x="48.0495%" y="383.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (197 samples, 0.50%)</title><rect x="47.7995%" y="357" width="0.5041%" height="15" fill="rgb(239,186,37)" fg:x="18681" fg:w="197"/><text x="48.0495%" y="367.50"></text></g><g><title>[libc.so.6] (194 samples, 0.50%)</title><rect x="47.8072%" y="341" width="0.4964%" height="15" fill="rgb(252,136,39)" fg:x="18684" fg:w="194"/><text x="48.0572%" y="351.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::is_ok (4 samples, 0.01%)</title><rect x="48.3036%" y="437" width="0.0102%" height="15" fill="rgb(223,213,32)" fg:x="18878" fg:w="4"/><text x="48.5536%" y="447.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (4 samples, 0.01%)</title><rect x="51.4303%" y="389" width="0.0102%" height="15" fill="rgb(233,115,5)" fg:x="20100" fg:w="4"/><text x="51.6803%" y="399.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (4 samples, 0.01%)</title><rect x="51.4406%" y="389" width="0.0102%" height="15" fill="rgb(207,226,44)" fg:x="20104" fg:w="4"/><text x="51.6906%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (66 samples, 0.17%)</title><rect x="51.5148%" y="373" width="0.1689%" height="15" fill="rgb(208,126,0)" fg:x="20133" fg:w="66"/><text x="51.7648%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (66 samples, 0.17%)</title><rect x="51.5148%" y="357" width="0.1689%" height="15" fill="rgb(244,66,21)" fg:x="20133" fg:w="66"/><text x="51.7648%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (102 samples, 0.26%)</title><rect x="51.4508%" y="389" width="0.2610%" height="15" fill="rgb(222,97,12)" fg:x="20108" fg:w="102"/><text x="51.7008%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (11 samples, 0.03%)</title><rect x="51.6836%" y="373" width="0.0281%" height="15" fill="rgb(219,213,19)" fg:x="20199" fg:w="11"/><text x="51.9336%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (11 samples, 0.03%)</title><rect x="51.6836%" y="357" width="0.0281%" height="15" fill="rgb(252,169,30)" fg:x="20199" fg:w="11"/><text x="51.9336%" y="367.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (6 samples, 0.02%)</title><rect x="51.7476%" y="357" width="0.0154%" height="15" fill="rgb(206,32,51)" fg:x="20224" fg:w="6"/><text x="51.9976%" y="367.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="51.7502%" y="341" width="0.0128%" height="15" fill="rgb(250,172,42)" fg:x="20225" fg:w="5"/><text x="52.0002%" y="351.50"></text></g><g><title>futex_wake_mark (8 samples, 0.02%)</title><rect x="51.8448%" y="149" width="0.0205%" height="15" fill="rgb(209,34,43)" fg:x="20262" fg:w="8"/><text x="52.0948%" y="159.50"></text></g><g><title>__smp_call_single_queue (7 samples, 0.02%)</title><rect x="51.9446%" y="101" width="0.0179%" height="15" fill="rgb(223,11,35)" fg:x="20301" fg:w="7"/><text x="52.1946%" y="111.50"></text></g><g><title>native_send_call_func_single_ipi (6 samples, 0.02%)</title><rect x="51.9472%" y="85" width="0.0154%" height="15" fill="rgb(251,219,26)" fg:x="20302" fg:w="6"/><text x="52.1972%" y="95.50"></text></g><g><title>x2apic_send_IPI (6 samples, 0.02%)</title><rect x="51.9472%" y="69" width="0.0154%" height="15" fill="rgb(231,119,3)" fg:x="20302" fg:w="6"/><text x="52.1972%" y="79.50"></text></g><g><title>native_write_msr (4 samples, 0.01%)</title><rect x="51.9523%" y="53" width="0.0102%" height="15" fill="rgb(216,97,11)" fg:x="20304" fg:w="4"/><text x="52.2023%" y="63.50"></text></g><g><title>llist_add_batch (7 samples, 0.02%)</title><rect x="51.9625%" y="101" width="0.0179%" height="15" fill="rgb(223,59,9)" fg:x="20308" fg:w="7"/><text x="52.2125%" y="111.50"></text></g><g><title>futex_wake (71 samples, 0.18%)</title><rect x="51.8013%" y="165" width="0.1817%" height="15" fill="rgb(233,93,31)" fg:x="20245" fg:w="71"/><text x="52.0513%" y="175.50"></text></g><g><title>wake_up_q (44 samples, 0.11%)</title><rect x="51.8704%" y="149" width="0.1126%" height="15" fill="rgb(239,81,33)" fg:x="20272" fg:w="44"/><text x="52.1204%" y="159.50"></text></g><g><title>try_to_wake_up (43 samples, 0.11%)</title><rect x="51.8730%" y="133" width="0.1100%" height="15" fill="rgb(213,120,34)" fg:x="20273" fg:w="43"/><text x="52.1230%" y="143.50"></text></g><g><title>ttwu_queue_wakelist (24 samples, 0.06%)</title><rect x="51.9216%" y="117" width="0.0614%" height="15" fill="rgb(243,49,53)" fg:x="20292" fg:w="24"/><text x="52.1716%" y="127.50"></text></g><g><title>__x64_sys_futex (75 samples, 0.19%)</title><rect x="51.7937%" y="197" width="0.1919%" height="15" fill="rgb(247,216,33)" fg:x="20242" fg:w="75"/><text x="52.0437%" y="207.50"></text></g><g><title>do_futex (75 samples, 0.19%)</title><rect x="51.7937%" y="181" width="0.1919%" height="15" fill="rgb(226,26,14)" fg:x="20242" fg:w="75"/><text x="52.0437%" y="191.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (76 samples, 0.19%)</title><rect x="51.7937%" y="229" width="0.1945%" height="15" fill="rgb(215,49,53)" fg:x="20242" fg:w="76"/><text x="52.0437%" y="239.50"></text></g><g><title>do_syscall_64 (76 samples, 0.19%)</title><rect x="51.7937%" y="213" width="0.1945%" height="15" fill="rgb(245,162,40)" fg:x="20242" fg:w="76"/><text x="52.0437%" y="223.50"></text></g><g><title>&lt;core::slice::iter::Iter&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::position (88 samples, 0.23%)</title><rect x="51.7655%" y="341" width="0.2252%" height="15" fill="rgb(229,68,17)" fg:x="20231" fg:w="88"/><text x="52.0155%" y="351.50"></text></g><g><title>std::sync::mpmc::waker::Waker::try_select::_{{closure}} (88 samples, 0.23%)</title><rect x="51.7655%" y="325" width="0.2252%" height="15" fill="rgb(213,182,10)" fg:x="20231" fg:w="88"/><text x="52.0155%" y="335.50"></text></g><g><title>std::sync::mpmc::context::Context::unpark (84 samples, 0.21%)</title><rect x="51.7758%" y="309" width="0.2149%" height="15" fill="rgb(245,125,30)" fg:x="20235" fg:w="84"/><text x="52.0258%" y="319.50"></text></g><g><title>std::thread::Thread::unpark (84 samples, 0.21%)</title><rect x="51.7758%" y="293" width="0.2149%" height="15" fill="rgb(232,202,2)" fg:x="20235" fg:w="84"/><text x="52.0258%" y="303.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::unpark (84 samples, 0.21%)</title><rect x="51.7758%" y="277" width="0.2149%" height="15" fill="rgb(237,140,51)" fg:x="20235" fg:w="84"/><text x="52.0258%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wake (81 samples, 0.21%)</title><rect x="51.7834%" y="261" width="0.2073%" height="15" fill="rgb(236,157,25)" fg:x="20238" fg:w="81"/><text x="52.0334%" y="271.50"></text></g><g><title>syscall (80 samples, 0.20%)</title><rect x="51.7860%" y="245" width="0.2047%" height="15" fill="rgb(219,209,0)" fg:x="20239" fg:w="80"/><text x="52.0360%" y="255.50"></text></g><g><title>std::sync::mpmc::waker::Waker::try_select (89 samples, 0.23%)</title><rect x="51.7655%" y="357" width="0.2277%" height="15" fill="rgb(240,116,54)" fg:x="20231" fg:w="89"/><text x="52.0155%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (112 samples, 0.29%)</title><rect x="51.7118%" y="389" width="0.2866%" height="15" fill="rgb(216,10,36)" fg:x="20210" fg:w="112"/><text x="51.9618%" y="399.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (105 samples, 0.27%)</title><rect x="51.7297%" y="373" width="0.2687%" height="15" fill="rgb(222,72,44)" fg:x="20217" fg:w="105"/><text x="51.9797%" y="383.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="51.9984%" y="101" width="0.0128%" height="15" fill="rgb(232,159,9)" fg:x="20322" fg:w="5"/><text x="52.2484%" y="111.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="51.9984%" y="85" width="0.0128%" height="15" fill="rgb(210,39,32)" fg:x="20322" fg:w="5"/><text x="52.2484%" y="95.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="51.9984%" y="69" width="0.0128%" height="15" fill="rgb(216,194,45)" fg:x="20322" fg:w="5"/><text x="52.2484%" y="79.50"></text></g><g><title>futex_wait_queue (6 samples, 0.02%)</title><rect x="51.9984%" y="149" width="0.0154%" height="15" fill="rgb(218,18,35)" fg:x="20322" fg:w="6"/><text x="52.2484%" y="159.50"></text></g><g><title>schedule (6 samples, 0.02%)</title><rect x="51.9984%" y="133" width="0.0154%" height="15" fill="rgb(207,83,51)" fg:x="20322" fg:w="6"/><text x="52.2484%" y="143.50"></text></g><g><title>__schedule (6 samples, 0.02%)</title><rect x="51.9984%" y="117" width="0.0154%" height="15" fill="rgb(225,63,43)" fg:x="20322" fg:w="6"/><text x="52.2484%" y="127.50"></text></g><g><title>std::sync::mpmc::context::Context::wait_until (7 samples, 0.02%)</title><rect x="51.9984%" y="309" width="0.0179%" height="15" fill="rgb(207,57,36)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="319.50"></text></g><g><title>std::thread::park (7 samples, 0.02%)</title><rect x="51.9984%" y="293" width="0.0179%" height="15" fill="rgb(216,99,33)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="303.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::park (7 samples, 0.02%)</title><rect x="51.9984%" y="277" width="0.0179%" height="15" fill="rgb(225,42,16)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wait (7 samples, 0.02%)</title><rect x="51.9984%" y="261" width="0.0179%" height="15" fill="rgb(220,201,45)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="271.50"></text></g><g><title>syscall (7 samples, 0.02%)</title><rect x="51.9984%" y="245" width="0.0179%" height="15" fill="rgb(225,33,4)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="255.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (7 samples, 0.02%)</title><rect x="51.9984%" y="229" width="0.0179%" height="15" fill="rgb(224,33,50)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="239.50"></text></g><g><title>do_syscall_64 (7 samples, 0.02%)</title><rect x="51.9984%" y="213" width="0.0179%" height="15" fill="rgb(246,198,51)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="223.50"></text></g><g><title>__x64_sys_futex (7 samples, 0.02%)</title><rect x="51.9984%" y="197" width="0.0179%" height="15" fill="rgb(205,22,4)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="207.50"></text></g><g><title>do_futex (7 samples, 0.02%)</title><rect x="51.9984%" y="181" width="0.0179%" height="15" fill="rgb(206,3,8)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="191.50"></text></g><g><title>futex_wait (7 samples, 0.02%)</title><rect x="51.9984%" y="165" width="0.0179%" height="15" fill="rgb(251,23,15)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="175.50"></text></g><g><title>std::sync::mpmc::context::Context::with (8 samples, 0.02%)</title><rect x="51.9984%" y="389" width="0.0205%" height="15" fill="rgb(252,88,28)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="399.50"></text></g><g><title>std::thread::local::LocalKey&lt;T&gt;::try_with (8 samples, 0.02%)</title><rect x="51.9984%" y="373" width="0.0205%" height="15" fill="rgb(212,127,14)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="383.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (8 samples, 0.02%)</title><rect x="51.9984%" y="357" width="0.0205%" height="15" fill="rgb(247,145,37)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="367.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (8 samples, 0.02%)</title><rect x="51.9984%" y="341" width="0.0205%" height="15" fill="rgb(209,117,53)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="351.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send::_{{closure}} (8 samples, 0.02%)</title><rect x="51.9984%" y="325" width="0.0205%" height="15" fill="rgb(212,90,42)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="335.50"></text></g><g><title>core::hint::spin_loop (14 samples, 0.04%)</title><rect x="52.0188%" y="373" width="0.0358%" height="15" fill="rgb(218,164,37)" fg:x="20330" fg:w="14"/><text x="52.2688%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_pause (14 samples, 0.04%)</title><rect x="52.0188%" y="357" width="0.0358%" height="15" fill="rgb(246,65,34)" fg:x="20330" fg:w="14"/><text x="52.2688%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (251 samples, 0.64%)</title><rect x="51.4150%" y="405" width="0.6422%" height="15" fill="rgb(231,100,33)" fg:x="20094" fg:w="251"/><text x="51.6650%" y="415.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::spin_light (15 samples, 0.04%)</title><rect x="52.0188%" y="389" width="0.0384%" height="15" fill="rgb(228,126,14)" fg:x="20330" fg:w="15"/><text x="52.2688%" y="399.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (3,468 samples, 8.87%)</title><rect x="43.1861%" y="453" width="8.8737%" height="15" fill="rgb(215,173,21)" fg:x="16878" fg:w="3468"/><text x="43.4361%" y="463.50">benchmark::bo..</text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (1,464 samples, 3.75%)</title><rect x="48.3138%" y="437" width="3.7460%" height="15" fill="rgb(210,6,40)" fg:x="18882" fg:w="1464"/><text x="48.5638%" y="447.50">std:..</text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (1,462 samples, 3.74%)</title><rect x="48.3189%" y="421" width="3.7409%" height="15" fill="rgb(212,48,18)" fg:x="18884" fg:w="1462"/><text x="48.5689%" y="431.50">std:..</text></g><g><title>core::iter::range::&lt;impl core::iter::traits::iterator::Iterator for core::ops::range::Range&lt;A&gt;&gt;::next (6 samples, 0.02%)</title><rect x="52.0598%" y="453" width="0.0154%" height="15" fill="rgb(230,214,11)" fg:x="20346" fg:w="6"/><text x="52.3098%" y="463.50"></text></g><g><title>&lt;core::ops::range::Range&lt;T&gt; as core::iter::range::RangeIteratorImpl&gt;::spec_next (6 samples, 0.02%)</title><rect x="52.0598%" y="437" width="0.0154%" height="15" fill="rgb(254,105,39)" fg:x="20346" fg:w="6"/><text x="52.3098%" y="447.50"></text></g><g><title>core::mem::drop (25 samples, 0.06%)</title><rect x="52.0751%" y="453" width="0.0640%" height="15" fill="rgb(245,158,5)" fg:x="20352" fg:w="25"/><text x="52.3251%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (25 samples, 0.06%)</title><rect x="52.0751%" y="437" width="0.0640%" height="15" fill="rgb(249,208,11)" fg:x="20352" fg:w="25"/><text x="52.3251%" y="447.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (25 samples, 0.06%)</title><rect x="52.0751%" y="421" width="0.0640%" height="15" fill="rgb(210,39,28)" fg:x="20352" fg:w="25"/><text x="52.3251%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (25 samples, 0.06%)</title><rect x="52.0751%" y="405" width="0.0640%" height="15" fill="rgb(211,56,53)" fg:x="20352" fg:w="25"/><text x="52.3251%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (24 samples, 0.06%)</title><rect x="52.0777%" y="389" width="0.0614%" height="15" fill="rgb(226,201,30)" fg:x="20353" fg:w="24"/><text x="52.3277%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_sub (24 samples, 0.06%)</title><rect x="52.0777%" y="373" width="0.0614%" height="15" fill="rgb(239,101,34)" fg:x="20353" fg:w="24"/><text x="52.3277%" y="383.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (14 samples, 0.04%)</title><rect x="52.1391%" y="453" width="0.0358%" height="15" fill="rgb(226,209,5)" fg:x="20377" fg:w="14"/><text x="52.3891%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (14 samples, 0.04%)</title><rect x="52.1391%" y="437" width="0.0358%" height="15" fill="rgb(250,105,47)" fg:x="20377" fg:w="14"/><text x="52.3891%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (20 samples, 0.05%)</title><rect x="52.1851%" y="421" width="0.0512%" height="15" fill="rgb(230,72,3)" fg:x="20395" fg:w="20"/><text x="52.4351%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (20 samples, 0.05%)</title><rect x="52.1851%" y="405" width="0.0512%" height="15" fill="rgb(232,218,39)" fg:x="20395" fg:w="20"/><text x="52.4351%" y="415.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (22 samples, 0.06%)</title><rect x="52.1851%" y="453" width="0.0563%" height="15" fill="rgb(248,166,6)" fg:x="20395" fg:w="22"/><text x="52.4351%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (22 samples, 0.06%)</title><rect x="52.1851%" y="437" width="0.0563%" height="15" fill="rgb(247,89,20)" fg:x="20395" fg:w="22"/><text x="52.4351%" y="447.50"></text></g><g><title>benchmark::alice_main (18,175 samples, 46.50%)</title><rect x="5.7725%" y="501" width="46.5048%" height="15" fill="rgb(248,130,54)" fg:x="2256" fg:w="18175"/><text x="6.0225%" y="511.50">benchmark::alice_main</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::send (8,691 samples, 22.24%)</title><rect x="30.0394%" y="485" width="22.2379%" height="15" fill="rgb(234,196,4)" fg:x="11740" fg:w="8691"/><text x="30.2894%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::send</text></g><g><title>zssp::zeta::send_payload (8,691 samples, 22.24%)</title><rect x="30.0394%" y="469" width="22.2379%" height="15" fill="rgb(250,143,31)" fg:x="11740" fg:w="8691"/><text x="30.2894%" y="479.50">zssp::zeta::send_payload</text></g><g><title>zssp::zeta::get_counter (14 samples, 0.04%)</title><rect x="52.2414%" y="453" width="0.0358%" height="15" fill="rgb(211,110,34)" fg:x="20417" fg:w="14"/><text x="52.4914%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_add (11 samples, 0.03%)</title><rect x="52.2491%" y="437" width="0.0281%" height="15" fill="rgb(215,124,48)" fg:x="20420" fg:w="11"/><text x="52.4991%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_add (11 samples, 0.03%)</title><rect x="52.2491%" y="421" width="0.0281%" height="15" fill="rgb(216,46,13)" fg:x="20420" fg:w="11"/><text x="52.4991%" y="431.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="52.3745%" y="485" width="0.0384%" height="15" fill="rgb(205,184,25)" fg:x="20469" fg:w="15"/><text x="52.6245%" y="495.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (4 samples, 0.01%)</title><rect x="52.4129%" y="485" width="0.0102%" height="15" fill="rgb(228,1,10)" fg:x="20484" fg:w="4"/><text x="52.6629%" y="495.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (4 samples, 0.01%)</title><rect x="52.4129%" y="469" width="0.0102%" height="15" fill="rgb(213,116,27)" fg:x="20484" fg:w="4"/><text x="52.6629%" y="479.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (4 samples, 0.01%)</title><rect x="52.4129%" y="453" width="0.0102%" height="15" fill="rgb(241,95,50)" fg:x="20484" fg:w="4"/><text x="52.6629%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (10 samples, 0.03%)</title><rect x="52.4257%" y="485" width="0.0256%" height="15" fill="rgb(238,48,32)" fg:x="20489" fg:w="10"/><text x="52.6757%" y="495.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (10 samples, 0.03%)</title><rect x="52.4257%" y="469" width="0.0256%" height="15" fill="rgb(235,113,49)" fg:x="20489" fg:w="10"/><text x="52.6757%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (10 samples, 0.03%)</title><rect x="52.4257%" y="453" width="0.0256%" height="15" fill="rgb(205,127,43)" fg:x="20489" fg:w="10"/><text x="52.6757%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_sub (10 samples, 0.03%)</title><rect x="52.4257%" y="437" width="0.0256%" height="15" fill="rgb(250,162,2)" fg:x="20489" fg:w="10"/><text x="52.6757%" y="447.50"></text></g><g><title>core::time::Duration::as_millis (5 samples, 0.01%)</title><rect x="52.4513%" y="485" width="0.0128%" height="15" fill="rgb(220,13,41)" fg:x="20499" fg:w="5"/><text x="52.7013%" y="495.50"></text></g><g><title>_ZN3std4sync4mpmc5array16Channel$LT$T$GT$10start_recv17h7800ca29c64cb868E.llvm.12455019271255371362 (4 samples, 0.01%)</title><rect x="52.5331%" y="421" width="0.0102%" height="15" fill="rgb(249,221,25)" fg:x="20531" fg:w="4"/><text x="52.7831%" y="431.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (6 samples, 0.02%)</title><rect x="52.5485%" y="421" width="0.0154%" height="15" fill="rgb(215,208,19)" fg:x="20537" fg:w="6"/><text x="52.7985%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (65 samples, 0.17%)</title><rect x="52.6585%" y="405" width="0.1663%" height="15" fill="rgb(236,175,2)" fg:x="20580" fg:w="65"/><text x="52.9085%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (65 samples, 0.17%)</title><rect x="52.6585%" y="389" width="0.1663%" height="15" fill="rgb(241,52,2)" fg:x="20580" fg:w="65"/><text x="52.9085%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (84 samples, 0.21%)</title><rect x="52.8248%" y="405" width="0.2149%" height="15" fill="rgb(248,140,14)" fg:x="20645" fg:w="84"/><text x="53.0748%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (84 samples, 0.21%)</title><rect x="52.8248%" y="389" width="0.2149%" height="15" fill="rgb(253,22,42)" fg:x="20645" fg:w="84"/><text x="53.0748%" y="399.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (190 samples, 0.49%)</title><rect x="52.5638%" y="421" width="0.4862%" height="15" fill="rgb(234,61,47)" fg:x="20543" fg:w="190"/><text x="52.8138%" y="431.50"></text></g><g><title>core::sync::atomic::fence (4 samples, 0.01%)</title><rect x="53.0398%" y="405" width="0.0102%" height="15" fill="rgb(208,226,15)" fg:x="20729" fg:w="4"/><text x="53.2898%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (5 samples, 0.01%)</title><rect x="53.0653%" y="293" width="0.0128%" height="15" fill="rgb(217,221,4)" fg:x="20739" fg:w="5"/><text x="53.3153%" y="303.50"></text></g><g><title>core::sync::atomic::atomic_swap (5 samples, 0.01%)</title><rect x="53.0653%" y="277" width="0.0128%" height="15" fill="rgb(212,174,34)" fg:x="20739" fg:w="5"/><text x="53.3153%" y="287.50"></text></g><g><title>[[vdso]] (4 samples, 0.01%)</title><rect x="53.0807%" y="213" width="0.0102%" height="15" fill="rgb(253,83,4)" fg:x="20745" fg:w="4"/><text x="53.3307%" y="223.50"></text></g><g><title>core::option::Option&lt;T&gt;::and_then (5 samples, 0.01%)</title><rect x="53.0807%" y="277" width="0.0128%" height="15" fill="rgb(250,195,49)" fg:x="20745" fg:w="5"/><text x="53.3307%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wait::_{{closure}} (5 samples, 0.01%)</title><rect x="53.0807%" y="261" width="0.0128%" height="15" fill="rgb(241,192,25)" fg:x="20745" fg:w="5"/><text x="53.3307%" y="271.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (5 samples, 0.01%)</title><rect x="53.0807%" y="245" width="0.0128%" height="15" fill="rgb(208,124,10)" fg:x="20745" fg:w="5"/><text x="53.3307%" y="255.50"></text></g><g><title>clock_gettime (5 samples, 0.01%)</title><rect x="53.0807%" y="229" width="0.0128%" height="15" fill="rgb(222,33,0)" fg:x="20745" fg:w="5"/><text x="53.3307%" y="239.50"></text></g><g><title>futex_setup_timer (5 samples, 0.01%)</title><rect x="53.1396%" y="181" width="0.0128%" height="15" fill="rgb(234,209,28)" fg:x="20768" fg:w="5"/><text x="53.3896%" y="191.50"></text></g><g><title>hrtimer_init_sleeper (4 samples, 0.01%)</title><rect x="53.1421%" y="165" width="0.0102%" height="15" fill="rgb(224,11,23)" fg:x="20769" fg:w="4"/><text x="53.3921%" y="175.50"></text></g><g><title>__hrtimer_init (4 samples, 0.01%)</title><rect x="53.1421%" y="149" width="0.0102%" height="15" fill="rgb(232,99,1)" fg:x="20769" fg:w="4"/><text x="53.3921%" y="159.50"></text></g><g><title>futex_unqueue (4 samples, 0.01%)</title><rect x="53.1523%" y="181" width="0.0102%" height="15" fill="rgb(237,95,45)" fg:x="20773" fg:w="4"/><text x="53.4023%" y="191.50"></text></g><g><title>hrtimer_sleeper_start_expires (6 samples, 0.02%)</title><rect x="53.1651%" y="165" width="0.0154%" height="15" fill="rgb(208,109,11)" fg:x="20778" fg:w="6"/><text x="53.4151%" y="175.50"></text></g><g><title>hrtimer_start_range_ns (6 samples, 0.02%)</title><rect x="53.1651%" y="149" width="0.0154%" height="15" fill="rgb(216,190,48)" fg:x="20778" fg:w="6"/><text x="53.4151%" y="159.50"></text></g><g><title>update_curr (5 samples, 0.01%)</title><rect x="53.2342%" y="85" width="0.0128%" height="15" fill="rgb(251,171,36)" fg:x="20805" fg:w="5"/><text x="53.4842%" y="95.50"></text></g><g><title>dequeue_entity (14 samples, 0.04%)</title><rect x="53.2240%" y="101" width="0.0358%" height="15" fill="rgb(230,62,22)" fg:x="20801" fg:w="14"/><text x="53.4740%" y="111.50"></text></g><g><title>update_load_avg (5 samples, 0.01%)</title><rect x="53.2470%" y="85" width="0.0128%" height="15" fill="rgb(225,114,35)" fg:x="20810" fg:w="5"/><text x="53.4970%" y="95.50"></text></g><g><title>dequeue_task (18 samples, 0.05%)</title><rect x="53.2189%" y="133" width="0.0461%" height="15" fill="rgb(215,118,42)" fg:x="20799" fg:w="18"/><text x="53.4689%" y="143.50"></text></g><g><title>dequeue_task_fair (18 samples, 0.05%)</title><rect x="53.2189%" y="117" width="0.0461%" height="15" fill="rgb(243,119,21)" fg:x="20799" fg:w="18"/><text x="53.4689%" y="127.50"></text></g><g><title>finish_task_switch.isra.0 (14 samples, 0.04%)</title><rect x="53.2649%" y="133" width="0.0358%" height="15" fill="rgb(252,177,53)" fg:x="20817" fg:w="14"/><text x="53.5149%" y="143.50"></text></g><g><title>raw_spin_rq_unlock (6 samples, 0.02%)</title><rect x="53.2854%" y="117" width="0.0154%" height="15" fill="rgb(237,209,29)" fg:x="20825" fg:w="6"/><text x="53.5354%" y="127.50"></text></g><g><title>pick_next_task (5 samples, 0.01%)</title><rect x="53.3008%" y="133" width="0.0128%" height="15" fill="rgb(212,65,23)" fg:x="20831" fg:w="5"/><text x="53.5508%" y="143.50"></text></g><g><title>prepare_task_switch (6 samples, 0.02%)</title><rect x="53.3135%" y="133" width="0.0154%" height="15" fill="rgb(230,222,46)" fg:x="20836" fg:w="6"/><text x="53.5635%" y="143.50"></text></g><g><title>__perf_event_task_sched_out (4 samples, 0.01%)</title><rect x="53.3187%" y="117" width="0.0102%" height="15" fill="rgb(215,135,32)" fg:x="20838" fg:w="4"/><text x="53.5687%" y="127.50"></text></g><g><title>psi_group_change (12 samples, 0.03%)</title><rect x="53.3391%" y="117" width="0.0307%" height="15" fill="rgb(246,101,22)" fg:x="20846" fg:w="12"/><text x="53.5891%" y="127.50"></text></g><g><title>record_times (5 samples, 0.01%)</title><rect x="53.3698%" y="117" width="0.0128%" height="15" fill="rgb(206,107,13)" fg:x="20858" fg:w="5"/><text x="53.6198%" y="127.50"></text></g><g><title>psi_task_switch (22 samples, 0.06%)</title><rect x="53.3315%" y="133" width="0.0563%" height="15" fill="rgb(250,100,44)" fg:x="20843" fg:w="22"/><text x="53.5815%" y="143.50"></text></g><g><title>__schedule (72 samples, 0.18%)</title><rect x="53.2061%" y="149" width="0.1842%" height="15" fill="rgb(231,147,38)" fg:x="20794" fg:w="72"/><text x="53.4561%" y="159.50"></text></g><g><title>futex_wait_queue (90 samples, 0.23%)</title><rect x="53.1626%" y="181" width="0.2303%" height="15" fill="rgb(229,8,40)" fg:x="20777" fg:w="90"/><text x="53.4126%" y="191.50"></text></g><g><title>schedule (81 samples, 0.21%)</title><rect x="53.1856%" y="165" width="0.2073%" height="15" fill="rgb(221,135,30)" fg:x="20786" fg:w="81"/><text x="53.4356%" y="175.50"></text></g><g><title>__get_user_nocheck_4 (6 samples, 0.02%)</title><rect x="53.3929%" y="165" width="0.0154%" height="15" fill="rgb(249,193,18)" fg:x="20867" fg:w="6"/><text x="53.6429%" y="175.50"></text></g><g><title>futex_q_lock (7 samples, 0.02%)</title><rect x="53.4210%" y="165" width="0.0179%" height="15" fill="rgb(209,133,39)" fg:x="20878" fg:w="7"/><text x="53.6710%" y="175.50"></text></g><g><title>futex_wait_setup (19 samples, 0.05%)</title><rect x="53.3929%" y="181" width="0.0486%" height="15" fill="rgb(232,100,14)" fg:x="20867" fg:w="19"/><text x="53.6429%" y="191.50"></text></g><g><title>hrtimer_cancel (5 samples, 0.01%)</title><rect x="53.4415%" y="181" width="0.0128%" height="15" fill="rgb(224,185,1)" fg:x="20886" fg:w="5"/><text x="53.6915%" y="191.50"></text></g><g><title>hrtimer_try_to_cancel (5 samples, 0.01%)</title><rect x="53.4415%" y="165" width="0.0128%" height="15" fill="rgb(223,139,8)" fg:x="20886" fg:w="5"/><text x="53.6915%" y="175.50"></text></g><g><title>do_futex (131 samples, 0.34%)</title><rect x="53.1268%" y="213" width="0.3352%" height="15" fill="rgb(232,213,38)" fg:x="20763" fg:w="131"/><text x="53.3768%" y="223.50"></text></g><g><title>futex_wait (130 samples, 0.33%)</title><rect x="53.1293%" y="197" width="0.3326%" height="15" fill="rgb(207,94,22)" fg:x="20764" fg:w="130"/><text x="53.3793%" y="207.50"></text></g><g><title>__x64_sys_futex (143 samples, 0.37%)</title><rect x="53.1088%" y="229" width="0.3659%" height="15" fill="rgb(219,183,54)" fg:x="20756" fg:w="143"/><text x="53.3588%" y="239.50"></text></g><g><title>get_timespec64 (5 samples, 0.01%)</title><rect x="53.4620%" y="213" width="0.0128%" height="15" fill="rgb(216,185,54)" fg:x="20894" fg:w="5"/><text x="53.7120%" y="223.50"></text></g><g><title>exit_to_user_mode_loop (11 samples, 0.03%)</title><rect x="53.4773%" y="197" width="0.0281%" height="15" fill="rgb(254,217,39)" fg:x="20900" fg:w="11"/><text x="53.7273%" y="207.50"></text></g><g><title>__rseq_handle_notify_resume (4 samples, 0.01%)</title><rect x="53.4952%" y="181" width="0.0102%" height="15" fill="rgb(240,178,23)" fg:x="20907" fg:w="4"/><text x="53.7452%" y="191.50"></text></g><g><title>std::sync::mpmc::context::Context::wait_until (178 samples, 0.46%)</title><rect x="53.0577%" y="341" width="0.4555%" height="15" fill="rgb(218,11,47)" fg:x="20736" fg:w="178"/><text x="53.3077%" y="351.50"></text></g><g><title>std::thread::park_timeout (177 samples, 0.45%)</title><rect x="53.0602%" y="325" width="0.4529%" height="15" fill="rgb(218,51,51)" fg:x="20737" fg:w="177"/><text x="53.3102%" y="335.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::park_timeout (175 samples, 0.45%)</title><rect x="53.0653%" y="309" width="0.4478%" height="15" fill="rgb(238,126,27)" fg:x="20739" fg:w="175"/><text x="53.3153%" y="319.50"></text></g><g><title>std::sys::unix::futex::futex_wait (170 samples, 0.43%)</title><rect x="53.0781%" y="293" width="0.4350%" height="15" fill="rgb(249,202,22)" fg:x="20744" fg:w="170"/><text x="53.3281%" y="303.50"></text></g><g><title>syscall (164 samples, 0.42%)</title><rect x="53.0935%" y="277" width="0.4196%" height="15" fill="rgb(254,195,49)" fg:x="20750" fg:w="164"/><text x="53.3435%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (159 samples, 0.41%)</title><rect x="53.1063%" y="261" width="0.4068%" height="15" fill="rgb(208,123,14)" fg:x="20755" fg:w="159"/><text x="53.3563%" y="271.50"></text></g><g><title>do_syscall_64 (159 samples, 0.41%)</title><rect x="53.1063%" y="245" width="0.4068%" height="15" fill="rgb(224,200,8)" fg:x="20755" fg:w="159"/><text x="53.3563%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (15 samples, 0.04%)</title><rect x="53.4747%" y="229" width="0.0384%" height="15" fill="rgb(217,61,36)" fg:x="20899" fg:w="15"/><text x="53.7247%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (15 samples, 0.04%)</title><rect x="53.4747%" y="213" width="0.0384%" height="15" fill="rgb(206,35,45)" fg:x="20899" fg:w="15"/><text x="53.7247%" y="223.50"></text></g><g><title>core::sync::atomic::AtomicBool::store (8 samples, 0.02%)</title><rect x="53.5208%" y="325" width="0.0205%" height="15" fill="rgb(217,65,33)" fg:x="20917" fg:w="8"/><text x="53.7708%" y="335.50"></text></g><g><title>core::sync::atomic::atomic_store (8 samples, 0.02%)</title><rect x="53.5208%" y="309" width="0.0205%" height="15" fill="rgb(222,158,48)" fg:x="20917" fg:w="8"/><text x="53.7708%" y="319.50"></text></g><g><title>std::sync::mpmc::waker::Waker::register (5 samples, 0.01%)</title><rect x="53.5413%" y="325" width="0.0128%" height="15" fill="rgb(254,2,54)" fg:x="20925" fg:w="5"/><text x="53.7913%" y="335.50"></text></g><g><title>std::sync::mpmc::waker::Waker::register_with_packet (5 samples, 0.01%)</title><rect x="53.5413%" y="309" width="0.0128%" height="15" fill="rgb(250,143,38)" fg:x="20925" fg:w="5"/><text x="53.7913%" y="319.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::push (5 samples, 0.01%)</title><rect x="53.5413%" y="293" width="0.0128%" height="15" fill="rgb(248,25,0)" fg:x="20925" fg:w="5"/><text x="53.7913%" y="303.50"></text></g><g><title>core::ptr::write (5 samples, 0.01%)</title><rect x="53.5413%" y="277" width="0.0128%" height="15" fill="rgb(206,152,27)" fg:x="20925" fg:w="5"/><text x="53.7913%" y="287.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::register (24 samples, 0.06%)</title><rect x="53.5131%" y="341" width="0.0614%" height="15" fill="rgb(240,77,30)" fg:x="20914" fg:w="24"/><text x="53.7631%" y="351.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (8 samples, 0.02%)</title><rect x="53.5541%" y="325" width="0.0205%" height="15" fill="rgb(231,5,3)" fg:x="20930" fg:w="8"/><text x="53.8041%" y="335.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (8 samples, 0.02%)</title><rect x="53.5541%" y="309" width="0.0205%" height="15" fill="rgb(207,226,32)" fg:x="20930" fg:w="8"/><text x="53.8041%" y="319.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (8 samples, 0.02%)</title><rect x="53.5541%" y="293" width="0.0205%" height="15" fill="rgb(222,207,47)" fg:x="20930" fg:w="8"/><text x="53.8041%" y="303.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (8 samples, 0.02%)</title><rect x="53.5541%" y="277" width="0.0205%" height="15" fill="rgb(229,115,45)" fg:x="20930" fg:w="8"/><text x="53.8041%" y="287.50"></text></g><g><title>std::sync::mpmc::context::Context::with (207 samples, 0.53%)</title><rect x="53.0500%" y="421" width="0.5297%" height="15" fill="rgb(224,191,6)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="431.50"></text></g><g><title>std::thread::local::LocalKey&lt;T&gt;::try_with (207 samples, 0.53%)</title><rect x="53.0500%" y="405" width="0.5297%" height="15" fill="rgb(230,227,24)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="415.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (207 samples, 0.53%)</title><rect x="53.0500%" y="389" width="0.5297%" height="15" fill="rgb(228,80,19)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="399.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (207 samples, 0.53%)</title><rect x="53.0500%" y="373" width="0.5297%" height="15" fill="rgb(247,229,0)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="383.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv::_{{closure}} (207 samples, 0.53%)</title><rect x="53.0500%" y="357" width="0.5297%" height="15" fill="rgb(237,194,15)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="367.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_deadline (431 samples, 1.10%)</title><rect x="52.4896%" y="453" width="1.1028%" height="15" fill="rgb(219,203,20)" fg:x="20514" fg:w="431"/><text x="52.7396%" y="463.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv (431 samples, 1.10%)</title><rect x="52.4896%" y="437" width="1.1028%" height="15" fill="rgb(234,128,8)" fg:x="20514" fg:w="431"/><text x="52.7396%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (5 samples, 0.01%)</title><rect x="53.5797%" y="421" width="0.0128%" height="15" fill="rgb(248,202,8)" fg:x="20940" fg:w="5"/><text x="53.8297%" y="431.50"></text></g><g><title>clock_gettime (5 samples, 0.01%)</title><rect x="53.5797%" y="405" width="0.0128%" height="15" fill="rgb(206,104,37)" fg:x="20940" fg:w="5"/><text x="53.8297%" y="415.50"></text></g><g><title>[[vdso]] (5 samples, 0.01%)</title><rect x="53.5797%" y="389" width="0.0128%" height="15" fill="rgb(223,8,27)" fg:x="20940" fg:w="5"/><text x="53.8297%" y="399.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (4 samples, 0.01%)</title><rect x="53.5924%" y="453" width="0.0102%" height="15" fill="rgb(216,217,28)" fg:x="20945" fg:w="4"/><text x="53.8424%" y="463.50"></text></g><g><title>[[vdso]] (131 samples, 0.34%)</title><rect x="53.6257%" y="421" width="0.3352%" height="15" fill="rgb(249,199,1)" fg:x="20958" fg:w="131"/><text x="53.8757%" y="431.50"></text></g><g><title>[[vdso]] (88 samples, 0.23%)</title><rect x="53.7357%" y="405" width="0.2252%" height="15" fill="rgb(240,85,17)" fg:x="21001" fg:w="88"/><text x="53.9857%" y="415.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (146 samples, 0.37%)</title><rect x="53.6027%" y="453" width="0.3736%" height="15" fill="rgb(206,108,45)" fg:x="20949" fg:w="146"/><text x="53.8527%" y="463.50"></text></g><g><title>clock_gettime (140 samples, 0.36%)</title><rect x="53.6180%" y="437" width="0.3582%" height="15" fill="rgb(245,210,41)" fg:x="20955" fg:w="140"/><text x="53.8680%" y="447.50"></text></g><g><title>__vdso_clock_gettime (6 samples, 0.02%)</title><rect x="53.9609%" y="421" width="0.0154%" height="15" fill="rgb(206,13,37)" fg:x="21089" fg:w="6"/><text x="54.2109%" y="431.50"></text></g><g><title>std::sync::mpsc::Receiver&lt;T&gt;::recv_timeout (605 samples, 1.55%)</title><rect x="52.4640%" y="485" width="1.5480%" height="15" fill="rgb(250,61,18)" fg:x="20504" fg:w="605"/><text x="52.7140%" y="495.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (602 samples, 1.54%)</title><rect x="52.4717%" y="469" width="1.5404%" height="15" fill="rgb(235,172,48)" fg:x="20507" fg:w="602"/><text x="52.7217%" y="479.50"></text></g><g><title>std::time::SystemTime::checked_add (12 samples, 0.03%)</title><rect x="53.9814%" y="453" width="0.0307%" height="15" fill="rgb(249,201,17)" fg:x="21097" fg:w="12"/><text x="54.2314%" y="463.50"></text></g><g><title>std::sys::unix::time::SystemTime::checked_add_duration (12 samples, 0.03%)</title><rect x="53.9814%" y="437" width="0.0307%" height="15" fill="rgb(219,208,6)" fg:x="21097" fg:w="12"/><text x="54.2314%" y="447.50"></text></g><g><title>std::sys::unix::time::Timespec::checked_add_duration (12 samples, 0.03%)</title><rect x="53.9814%" y="421" width="0.0307%" height="15" fill="rgb(248,31,23)" fg:x="21097" fg:w="12"/><text x="54.2314%" y="431.50"></text></g><g><title>core::option::Option&lt;T&gt;::and_then (4 samples, 0.01%)</title><rect x="54.0018%" y="405" width="0.0102%" height="15" fill="rgb(245,15,42)" fg:x="21105" fg:w="4"/><text x="54.2518%" y="415.50"></text></g><g><title>core::cmp::impls::&lt;impl core::cmp::PartialOrd&lt;&amp;B&gt; for &amp;A&gt;::ge (6 samples, 0.02%)</title><rect x="54.0607%" y="389" width="0.0154%" height="15" fill="rgb(222,217,39)" fg:x="21128" fg:w="6"/><text x="54.3107%" y="399.50"></text></g><g><title>core::cmp::PartialOrd::ge (6 samples, 0.02%)</title><rect x="54.0607%" y="373" width="0.0154%" height="15" fill="rgb(210,219,27)" fg:x="21128" fg:w="6"/><text x="54.3107%" y="383.50"></text></g><g><title>&lt;std::sys::unix::time::Timespec as core::cmp::PartialOrd&gt;::partial_cmp (5 samples, 0.01%)</title><rect x="54.0633%" y="357" width="0.0128%" height="15" fill="rgb(252,166,36)" fg:x="21129" fg:w="5"/><text x="54.3133%" y="367.50"></text></g><g><title>std::time::Instant::duration_since (22 samples, 0.06%)</title><rect x="54.0274%" y="453" width="0.0563%" height="15" fill="rgb(245,132,34)" fg:x="21115" fg:w="22"/><text x="54.2774%" y="463.50"></text></g><g><title>std::time::Instant::checked_duration_since (21 samples, 0.05%)</title><rect x="54.0300%" y="437" width="0.0537%" height="15" fill="rgb(236,54,3)" fg:x="21116" fg:w="21"/><text x="54.2800%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (21 samples, 0.05%)</title><rect x="54.0300%" y="421" width="0.0537%" height="15" fill="rgb(241,173,43)" fg:x="21116" fg:w="21"/><text x="54.2800%" y="431.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (21 samples, 0.05%)</title><rect x="54.0300%" y="405" width="0.0537%" height="15" fill="rgb(215,190,9)" fg:x="21116" fg:w="21"/><text x="54.2800%" y="415.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (27 samples, 0.07%)</title><rect x="54.0274%" y="469" width="0.0691%" height="15" fill="rgb(242,101,16)" fg:x="21115" fg:w="27"/><text x="54.2774%" y="479.50"></text></g><g><title>std::time::Instant::elapsed (5 samples, 0.01%)</title><rect x="54.0837%" y="453" width="0.0128%" height="15" fill="rgb(223,190,21)" fg:x="21137" fg:w="5"/><text x="54.3337%" y="463.50"></text></g><g><title>[[vdso]] (148 samples, 0.38%)</title><rect x="54.1144%" y="405" width="0.3787%" height="15" fill="rgb(215,228,25)" fg:x="21149" fg:w="148"/><text x="54.3644%" y="415.50"></text></g><g><title>[[vdso]] (107 samples, 0.27%)</title><rect x="54.2193%" y="389" width="0.2738%" height="15" fill="rgb(225,36,22)" fg:x="21190" fg:w="107"/><text x="54.4693%" y="399.50"></text></g><g><title>std::time::Instant::elapsed (192 samples, 0.49%)</title><rect x="54.0121%" y="485" width="0.4913%" height="15" fill="rgb(251,106,46)" fg:x="21109" fg:w="192"/><text x="54.2621%" y="495.50"></text></g><g><title>std::time::Instant::now (159 samples, 0.41%)</title><rect x="54.0965%" y="469" width="0.4068%" height="15" fill="rgb(208,90,1)" fg:x="21142" fg:w="159"/><text x="54.3465%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::Instant::now (159 samples, 0.41%)</title><rect x="54.0965%" y="453" width="0.4068%" height="15" fill="rgb(243,10,4)" fg:x="21142" fg:w="159"/><text x="54.3465%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (155 samples, 0.40%)</title><rect x="54.1067%" y="437" width="0.3966%" height="15" fill="rgb(212,137,27)" fg:x="21146" fg:w="155"/><text x="54.3567%" y="447.50"></text></g><g><title>clock_gettime (154 samples, 0.39%)</title><rect x="54.1093%" y="421" width="0.3940%" height="15" fill="rgb(231,220,49)" fg:x="21147" fg:w="154"/><text x="54.3593%" y="431.50"></text></g><g><title>__vdso_clock_gettime (4 samples, 0.01%)</title><rect x="54.4931%" y="405" width="0.0102%" height="15" fill="rgb(237,96,20)" fg:x="21297" fg:w="4"/><text x="54.7431%" y="415.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (306 samples, 0.78%)</title><rect x="54.7029%" y="469" width="0.7830%" height="15" fill="rgb(239,229,30)" fg:x="21379" fg:w="306"/><text x="54.9529%" y="479.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (306 samples, 0.78%)</title><rect x="54.7029%" y="453" width="0.7830%" height="15" fill="rgb(219,65,33)" fg:x="21379" fg:w="306"/><text x="54.9529%" y="463.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (306 samples, 0.78%)</title><rect x="54.7029%" y="437" width="0.7830%" height="15" fill="rgb(243,134,7)" fg:x="21379" fg:w="306"/><text x="54.9529%" y="447.50"></text></g><g><title>&lt;core::result::Result&lt;T,E&gt; as core::ops::try_trait::Try&gt;::branch (13 samples, 0.03%)</title><rect x="55.4859%" y="469" width="0.0333%" height="15" fill="rgb(216,177,54)" fg:x="21685" fg:w="13"/><text x="55.7359%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (61 samples, 0.16%)</title><rect x="55.5345%" y="453" width="0.1561%" height="15" fill="rgb(211,160,20)" fg:x="21704" fg:w="61"/><text x="55.7845%" y="463.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (61 samples, 0.16%)</title><rect x="55.5345%" y="437" width="0.1561%" height="15" fill="rgb(239,85,39)" fg:x="21704" fg:w="61"/><text x="55.7845%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (60 samples, 0.15%)</title><rect x="55.5371%" y="421" width="0.1535%" height="15" fill="rgb(232,125,22)" fg:x="21705" fg:w="60"/><text x="55.7871%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (56 samples, 0.14%)</title><rect x="55.5473%" y="405" width="0.1433%" height="15" fill="rgb(244,57,34)" fg:x="21709" fg:w="56"/><text x="55.7973%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_swap (56 samples, 0.14%)</title><rect x="55.5473%" y="389" width="0.1433%" height="15" fill="rgb(214,203,32)" fg:x="21709" fg:w="56"/><text x="55.7973%" y="399.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (6 samples, 0.02%)</title><rect x="55.6906%" y="437" width="0.0154%" height="15" fill="rgb(207,58,43)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="447.50"></text></g><g><title>std::sync::poison::Flag::guard (6 samples, 0.02%)</title><rect x="55.6906%" y="421" width="0.0154%" height="15" fill="rgb(215,193,15)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="431.50"></text></g><g><title>std::thread::panicking (6 samples, 0.02%)</title><rect x="55.6906%" y="405" width="0.0154%" height="15" fill="rgb(232,15,44)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="415.50"></text></g><g><title>std::panicking::panicking (6 samples, 0.02%)</title><rect x="55.6906%" y="389" width="0.0154%" height="15" fill="rgb(212,3,48)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="399.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (6 samples, 0.02%)</title><rect x="55.6906%" y="373" width="0.0154%" height="15" fill="rgb(218,128,7)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (77 samples, 0.20%)</title><rect x="55.6906%" y="453" width="0.1970%" height="15" fill="rgb(226,216,39)" fg:x="21765" fg:w="77"/><text x="55.9406%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (71 samples, 0.18%)</title><rect x="55.7060%" y="437" width="0.1817%" height="15" fill="rgb(243,47,51)" fg:x="21771" fg:w="71"/><text x="55.9560%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (69 samples, 0.18%)</title><rect x="55.7111%" y="421" width="0.1766%" height="15" fill="rgb(241,183,40)" fg:x="21773" fg:w="69"/><text x="55.9611%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (69 samples, 0.18%)</title><rect x="55.7111%" y="405" width="0.1766%" height="15" fill="rgb(231,217,32)" fg:x="21773" fg:w="69"/><text x="55.9611%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_get_block_size (5 samples, 0.01%)</title><rect x="55.9618%" y="421" width="0.0128%" height="15" fill="rgb(229,61,38)" fg:x="21871" fg:w="5"/><text x="56.2118%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (344 samples, 0.88%)</title><rect x="55.5192%" y="469" width="0.8802%" height="15" fill="rgb(225,210,5)" fg:x="21698" fg:w="344"/><text x="55.7692%" y="479.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (200 samples, 0.51%)</title><rect x="55.8876%" y="453" width="0.5117%" height="15" fill="rgb(231,79,45)" fg:x="21842" fg:w="200"/><text x="56.1376%" y="463.50"></text></g><g><title>EVP_DecryptUpdate (196 samples, 0.50%)</title><rect x="55.8979%" y="437" width="0.5015%" height="15" fill="rgb(224,100,7)" fg:x="21846" fg:w="196"/><text x="56.1479%" y="447.50"></text></g><g><title>[libcrypto.so.3] (166 samples, 0.42%)</title><rect x="55.9746%" y="421" width="0.4247%" height="15" fill="rgb(241,198,18)" fg:x="21876" fg:w="166"/><text x="56.2246%" y="431.50"></text></g><g><title>[libcrypto.so.3] (119 samples, 0.30%)</title><rect x="56.0949%" y="405" width="0.3045%" height="15" fill="rgb(252,97,53)" fg:x="21923" fg:w="119"/><text x="56.3449%" y="415.50"></text></g><g><title>[libcrypto.so.3] (113 samples, 0.29%)</title><rect x="56.1102%" y="389" width="0.2891%" height="15" fill="rgb(220,88,7)" fg:x="21929" fg:w="113"/><text x="56.3602%" y="399.50"></text></g><g><title>__rust_probestack (9 samples, 0.02%)</title><rect x="56.3994%" y="469" width="0.0230%" height="15" fill="rgb(213,176,14)" fg:x="22042" fg:w="9"/><text x="56.6494%" y="479.50"></text></g><g><title>core::cmp::Ord::max (5 samples, 0.01%)</title><rect x="56.4250%" y="469" width="0.0128%" height="15" fill="rgb(246,73,7)" fg:x="22052" fg:w="5"/><text x="56.6750%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (5 samples, 0.01%)</title><rect x="56.4250%" y="453" width="0.0128%" height="15" fill="rgb(245,64,36)" fg:x="22052" fg:w="5"/><text x="56.6750%" y="463.50"></text></g><g><title>core::num::nonzero::NonZeroU32::new (6 samples, 0.02%)</title><rect x="56.4377%" y="469" width="0.0154%" height="15" fill="rgb(245,80,10)" fg:x="22057" fg:w="6"/><text x="56.6877%" y="479.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="56.4403%" y="453" width="0.0128%" height="15" fill="rgb(232,107,50)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="463.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="56.4403%" y="437" width="0.0128%" height="15" fill="rgb(253,3,0)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="447.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="56.4403%" y="421" width="0.0128%" height="15" fill="rgb(212,99,53)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="431.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="56.4403%" y="405" width="0.0128%" height="15" fill="rgb(249,111,54)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="415.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="56.4403%" y="389" width="0.0128%" height="15" fill="rgb(249,55,30)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="399.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="56.4403%" y="373" width="0.0128%" height="15" fill="rgb(237,47,42)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="383.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="56.4403%" y="357" width="0.0128%" height="15" fill="rgb(211,20,18)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="367.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="56.4403%" y="341" width="0.0128%" height="15" fill="rgb(231,203,46)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="351.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="56.4403%" y="325" width="0.0128%" height="15" fill="rgb(237,142,3)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="335.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="56.4403%" y="309" width="0.0128%" height="15" fill="rgb(241,107,1)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="319.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="56.4403%" y="293" width="0.0128%" height="15" fill="rgb(229,83,13)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="303.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade::_{{closure}} (7 samples, 0.02%)</title><rect x="56.4710%" y="405" width="0.0179%" height="15" fill="rgb(241,91,40)" fg:x="22070" fg:w="7"/><text x="56.7210%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (43 samples, 0.11%)</title><rect x="56.4889%" y="405" width="0.1100%" height="15" fill="rgb(225,3,45)" fg:x="22077" fg:w="43"/><text x="56.7389%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (43 samples, 0.11%)</title><rect x="56.4889%" y="389" width="0.1100%" height="15" fill="rgb(244,223,14)" fg:x="22077" fg:w="43"/><text x="56.7389%" y="399.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade (63 samples, 0.16%)</title><rect x="56.4531%" y="437" width="0.1612%" height="15" fill="rgb(224,124,37)" fg:x="22063" fg:w="63"/><text x="56.7031%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_update (61 samples, 0.16%)</title><rect x="56.4582%" y="421" width="0.1561%" height="15" fill="rgb(251,171,30)" fg:x="22065" fg:w="61"/><text x="56.7082%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (6 samples, 0.02%)</title><rect x="56.5989%" y="405" width="0.0154%" height="15" fill="rgb(236,46,54)" fg:x="22120" fg:w="6"/><text x="56.8489%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="56.5989%" y="389" width="0.0154%" height="15" fill="rgb(245,213,5)" fg:x="22120" fg:w="6"/><text x="56.8489%" y="399.50"></text></g><g><title>core::option::Option&lt;T&gt;::map (71 samples, 0.18%)</title><rect x="56.4531%" y="469" width="0.1817%" height="15" fill="rgb(230,144,27)" fg:x="22063" fg:w="71"/><text x="56.7031%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive::_{{closure}} (71 samples, 0.18%)</title><rect x="56.4531%" y="453" width="0.1817%" height="15" fill="rgb(220,86,6)" fg:x="22063" fg:w="71"/><text x="56.7031%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8 samples, 0.02%)</title><rect x="56.6143%" y="437" width="0.0205%" height="15" fill="rgb(240,20,13)" fg:x="22126" fg:w="8"/><text x="56.8643%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (55 samples, 0.14%)</title><rect x="56.6348%" y="469" width="0.1407%" height="15" fill="rgb(217,89,34)" fg:x="22134" fg:w="55"/><text x="56.8848%" y="479.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (55 samples, 0.14%)</title><rect x="56.6348%" y="453" width="0.1407%" height="15" fill="rgb(229,13,5)" fg:x="22134" fg:w="55"/><text x="56.8848%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (53 samples, 0.14%)</title><rect x="56.6399%" y="437" width="0.1356%" height="15" fill="rgb(244,67,35)" fg:x="22136" fg:w="53"/><text x="56.8899%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_sub (53 samples, 0.14%)</title><rect x="56.6399%" y="421" width="0.1356%" height="15" fill="rgb(221,40,2)" fg:x="22136" fg:w="53"/><text x="56.8899%" y="431.50"></text></g><g><title>__rdl_dealloc (4 samples, 0.01%)</title><rect x="56.7832%" y="293" width="0.0102%" height="15" fill="rgb(237,157,21)" fg:x="22192" fg:w="4"/><text x="57.0332%" y="303.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::dealloc (4 samples, 0.01%)</title><rect x="56.7832%" y="277" width="0.0102%" height="15" fill="rgb(222,94,11)" fg:x="22192" fg:w="4"/><text x="57.0332%" y="287.50"></text></g><g><title>[libc.so.6] (73 samples, 0.19%)</title><rect x="57.9346%" y="261" width="0.1868%" height="15" fill="rgb(249,113,6)" fg:x="22642" fg:w="73"/><text x="58.1846%" y="271.50"></text></g><g><title>__entry_text_start (13 samples, 0.03%)</title><rect x="58.2109%" y="245" width="0.0333%" height="15" fill="rgb(238,137,36)" fg:x="22750" fg:w="13"/><text x="58.4609%" y="255.50"></text></g><g><title>futex_unqueue (8 samples, 0.02%)</title><rect x="58.3133%" y="165" width="0.0205%" height="15" fill="rgb(210,102,26)" fg:x="22790" fg:w="8"/><text x="58.5633%" y="175.50"></text></g><g><title>update_curr (16 samples, 0.04%)</title><rect x="58.4131%" y="69" width="0.0409%" height="15" fill="rgb(218,30,30)" fg:x="22829" fg:w="16"/><text x="58.6631%" y="79.50"></text></g><g><title>cpuacct_charge (8 samples, 0.02%)</title><rect x="58.4335%" y="53" width="0.0205%" height="15" fill="rgb(214,67,26)" fg:x="22837" fg:w="8"/><text x="58.6835%" y="63.50"></text></g><g><title>dequeue_entity (23 samples, 0.06%)</title><rect x="58.4054%" y="85" width="0.0589%" height="15" fill="rgb(251,9,53)" fg:x="22826" fg:w="23"/><text x="58.6554%" y="95.50"></text></g><g><title>update_load_avg (4 samples, 0.01%)</title><rect x="58.4540%" y="69" width="0.0102%" height="15" fill="rgb(228,204,25)" fg:x="22845" fg:w="4"/><text x="58.7040%" y="79.50"></text></g><g><title>dequeue_task_fair (28 samples, 0.07%)</title><rect x="58.4003%" y="101" width="0.0716%" height="15" fill="rgb(207,153,8)" fg:x="22824" fg:w="28"/><text x="58.6503%" y="111.50"></text></g><g><title>dequeue_task (29 samples, 0.07%)</title><rect x="58.4003%" y="117" width="0.0742%" height="15" fill="rgb(242,9,16)" fg:x="22824" fg:w="29"/><text x="58.6503%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (8 samples, 0.02%)</title><rect x="58.4822%" y="101" width="0.0205%" height="15" fill="rgb(217,211,10)" fg:x="22856" fg:w="8"/><text x="58.7322%" y="111.50"></text></g><g><title>perf_ctx_enable (8 samples, 0.02%)</title><rect x="58.4822%" y="85" width="0.0205%" height="15" fill="rgb(219,228,52)" fg:x="22856" fg:w="8"/><text x="58.7322%" y="95.50"></text></g><g><title>x86_pmu_enable (4 samples, 0.01%)</title><rect x="58.4924%" y="69" width="0.0102%" height="15" fill="rgb(231,92,29)" fg:x="22860" fg:w="4"/><text x="58.7424%" y="79.50"></text></g><g><title>intel_pmu_enable_all (4 samples, 0.01%)</title><rect x="58.4924%" y="53" width="0.0102%" height="15" fill="rgb(232,8,23)" fg:x="22860" fg:w="4"/><text x="58.7424%" y="63.50"></text></g><g><title>native_write_msr (4 samples, 0.01%)</title><rect x="58.4924%" y="37" width="0.0102%" height="15" fill="rgb(216,211,34)" fg:x="22860" fg:w="4"/><text x="58.7424%" y="47.50"></text></g><g><title>finish_task_switch.isra.0 (19 samples, 0.05%)</title><rect x="58.4745%" y="117" width="0.0486%" height="15" fill="rgb(236,151,0)" fg:x="22853" fg:w="19"/><text x="58.7245%" y="127.50"></text></g><g><title>raw_spin_rq_unlock (5 samples, 0.01%)</title><rect x="58.5103%" y="101" width="0.0128%" height="15" fill="rgb(209,168,3)" fg:x="22867" fg:w="5"/><text x="58.7603%" y="111.50"></text></g><g><title>pick_next_task_fair (5 samples, 0.01%)</title><rect x="58.5257%" y="101" width="0.0128%" height="15" fill="rgb(208,129,28)" fg:x="22873" fg:w="5"/><text x="58.7757%" y="111.50"></text></g><g><title>pick_next_task (10 samples, 0.03%)</title><rect x="58.5231%" y="117" width="0.0256%" height="15" fill="rgb(229,78,22)" fg:x="22872" fg:w="10"/><text x="58.7731%" y="127.50"></text></g><g><title>put_prev_task_fair (4 samples, 0.01%)</title><rect x="58.5385%" y="101" width="0.0102%" height="15" fill="rgb(228,187,13)" fg:x="22878" fg:w="4"/><text x="58.7885%" y="111.50"></text></g><g><title>prepare_task_switch (16 samples, 0.04%)</title><rect x="58.5513%" y="117" width="0.0409%" height="15" fill="rgb(240,119,24)" fg:x="22883" fg:w="16"/><text x="58.8013%" y="127.50"></text></g><g><title>__perf_event_task_sched_out (5 samples, 0.01%)</title><rect x="58.5794%" y="101" width="0.0128%" height="15" fill="rgb(209,194,42)" fg:x="22894" fg:w="5"/><text x="58.8294%" y="111.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="58.5820%" y="85" width="0.0102%" height="15" fill="rgb(247,200,46)" fg:x="22895" fg:w="4"/><text x="58.8320%" y="95.50"></text></g><g><title>psi_group_change (22 samples, 0.06%)</title><rect x="58.6280%" y="101" width="0.0563%" height="15" fill="rgb(218,76,16)" fg:x="22913" fg:w="22"/><text x="58.8780%" y="111.50"></text></g><g><title>psi_task_switch (35 samples, 0.09%)</title><rect x="58.5973%" y="117" width="0.0896%" height="15" fill="rgb(225,21,48)" fg:x="22901" fg:w="35"/><text x="58.8473%" y="127.50"></text></g><g><title>futex_wait_queue (143 samples, 0.37%)</title><rect x="58.3338%" y="165" width="0.3659%" height="15" fill="rgb(239,223,50)" fg:x="22798" fg:w="143"/><text x="58.5838%" y="175.50"></text></g><g><title>schedule (136 samples, 0.35%)</title><rect x="58.3517%" y="149" width="0.3480%" height="15" fill="rgb(244,45,21)" fg:x="22805" fg:w="136"/><text x="58.6017%" y="159.50"></text></g><g><title>__schedule (130 samples, 0.33%)</title><rect x="58.3670%" y="133" width="0.3326%" height="15" fill="rgb(232,33,43)" fg:x="22811" fg:w="130"/><text x="58.6170%" y="143.50"></text></g><g><title>__get_user_nocheck_4 (8 samples, 0.02%)</title><rect x="58.7125%" y="149" width="0.0205%" height="15" fill="rgb(209,8,3)" fg:x="22946" fg:w="8"/><text x="58.9625%" y="159.50"></text></g><g><title>_raw_spin_lock (6 samples, 0.02%)</title><rect x="58.7329%" y="149" width="0.0154%" height="15" fill="rgb(214,25,53)" fg:x="22954" fg:w="6"/><text x="58.9829%" y="159.50"></text></g><g><title>futex_q_lock (8 samples, 0.02%)</title><rect x="58.7508%" y="149" width="0.0205%" height="15" fill="rgb(254,186,54)" fg:x="22961" fg:w="8"/><text x="59.0008%" y="159.50"></text></g><g><title>futex_wait (192 samples, 0.49%)</title><rect x="58.2851%" y="181" width="0.4913%" height="15" fill="rgb(208,174,49)" fg:x="22779" fg:w="192"/><text x="58.5351%" y="191.50"></text></g><g><title>futex_wait_setup (30 samples, 0.08%)</title><rect x="58.6997%" y="165" width="0.0768%" height="15" fill="rgb(233,191,51)" fg:x="22941" fg:w="30"/><text x="58.9497%" y="175.50"></text></g><g><title>__x64_sys_futex (201 samples, 0.51%)</title><rect x="58.2647%" y="213" width="0.5143%" height="15" fill="rgb(222,134,10)" fg:x="22771" fg:w="201"/><text x="58.5147%" y="223.50"></text></g><g><title>do_futex (200 samples, 0.51%)</title><rect x="58.2672%" y="197" width="0.5117%" height="15" fill="rgb(230,226,20)" fg:x="22772" fg:w="200"/><text x="58.5172%" y="207.50"></text></g><g><title>__rseq_handle_notify_resume (7 samples, 0.02%)</title><rect x="58.8122%" y="165" width="0.0179%" height="15" fill="rgb(251,111,25)" fg:x="22985" fg:w="7"/><text x="59.0622%" y="175.50"></text></g><g><title>rseq_update_cpu_node_id (5 samples, 0.01%)</title><rect x="58.8174%" y="149" width="0.0128%" height="15" fill="rgb(224,40,46)" fg:x="22987" fg:w="5"/><text x="59.0674%" y="159.50"></text></g><g><title>exit_to_user_mode_loop (12 samples, 0.03%)</title><rect x="58.8020%" y="181" width="0.0307%" height="15" fill="rgb(236,108,47)" fg:x="22981" fg:w="12"/><text x="59.0520%" y="191.50"></text></g><g><title>exit_to_user_mode_prepare (19 samples, 0.05%)</title><rect x="58.7892%" y="197" width="0.0486%" height="15" fill="rgb(234,93,0)" fg:x="22976" fg:w="19"/><text x="59.0392%" y="207.50"></text></g><g><title>do_syscall_64 (227 samples, 0.58%)</title><rect x="58.2596%" y="229" width="0.5808%" height="15" fill="rgb(224,213,32)" fg:x="22769" fg:w="227"/><text x="58.5096%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (22 samples, 0.06%)</title><rect x="58.7841%" y="213" width="0.0563%" height="15" fill="rgb(251,11,48)" fg:x="22974" fg:w="22"/><text x="59.0341%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (233 samples, 0.60%)</title><rect x="58.2468%" y="245" width="0.5962%" height="15" fill="rgb(236,173,5)" fg:x="22764" fg:w="233"/><text x="58.4968%" y="255.50"></text></g><g><title>__lll_lock_wait_private (283 samples, 0.72%)</title><rect x="58.1214%" y="261" width="0.7241%" height="15" fill="rgb(230,95,12)" fg:x="22715" fg:w="283"/><text x="58.3714%" y="271.50"></text></g><g><title>[libc.so.6] (759 samples, 1.94%)</title><rect x="56.9060%" y="277" width="1.9421%" height="15" fill="rgb(232,209,1)" fg:x="22240" fg:w="759"/><text x="57.1560%" y="287.50">[..</text></g><g><title>__entry_text_start (8 samples, 0.02%)</title><rect x="58.8711%" y="261" width="0.0205%" height="15" fill="rgb(232,6,1)" fg:x="23008" fg:w="8"/><text x="59.1211%" y="271.50"></text></g><g><title>futex_hash (7 samples, 0.02%)</title><rect x="58.9171%" y="197" width="0.0179%" height="15" fill="rgb(210,224,50)" fg:x="23026" fg:w="7"/><text x="59.1671%" y="207.50"></text></g><g><title>_raw_spin_lock (12 samples, 0.03%)</title><rect x="59.0297%" y="181" width="0.0307%" height="15" fill="rgb(228,127,35)" fg:x="23070" fg:w="12"/><text x="59.2797%" y="191.50"></text></g><g><title>native_queued_spin_lock_slowpath (12 samples, 0.03%)</title><rect x="59.0297%" y="165" width="0.0307%" height="15" fill="rgb(245,102,45)" fg:x="23070" fg:w="12"/><text x="59.2797%" y="175.50"></text></g><g><title>__x64_sys_futex (65 samples, 0.17%)</title><rect x="58.8992%" y="229" width="0.1663%" height="15" fill="rgb(214,1,49)" fg:x="23019" fg:w="65"/><text x="59.1492%" y="239.50"></text></g><g><title>do_futex (61 samples, 0.16%)</title><rect x="58.9095%" y="213" width="0.1561%" height="15" fill="rgb(226,163,40)" fg:x="23023" fg:w="61"/><text x="59.1595%" y="223.50"></text></g><g><title>futex_wake (51 samples, 0.13%)</title><rect x="58.9351%" y="197" width="0.1305%" height="15" fill="rgb(239,212,28)" fg:x="23033" fg:w="51"/><text x="59.1851%" y="207.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (78 samples, 0.20%)</title><rect x="58.8916%" y="261" width="0.1996%" height="15" fill="rgb(220,20,13)" fg:x="23016" fg:w="78"/><text x="59.1416%" y="271.50"></text></g><g><title>do_syscall_64 (77 samples, 0.20%)</title><rect x="58.8941%" y="245" width="0.1970%" height="15" fill="rgb(210,164,35)" fg:x="23017" fg:w="77"/><text x="59.1441%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (6 samples, 0.02%)</title><rect x="59.0758%" y="229" width="0.0154%" height="15" fill="rgb(248,109,41)" fg:x="23088" fg:w="6"/><text x="59.3258%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (6 samples, 0.02%)</title><rect x="59.0758%" y="213" width="0.0154%" height="15" fill="rgb(238,23,50)" fg:x="23088" fg:w="6"/><text x="59.3258%" y="223.50"></text></g><g><title>alloc::alloc::dealloc (903 samples, 2.31%)</title><rect x="56.7832%" y="309" width="2.3105%" height="15" fill="rgb(211,48,49)" fg:x="22192" fg:w="903"/><text x="57.0332%" y="319.50">a..</text></g><g><title>cfree (896 samples, 2.29%)</title><rect x="56.8011%" y="293" width="2.2926%" height="15" fill="rgb(223,36,21)" fg:x="22199" fg:w="896"/><text x="57.0511%" y="303.50">c..</text></g><g><title>__lll_lock_wake_private (96 samples, 0.25%)</title><rect x="58.8481%" y="277" width="0.2456%" height="15" fill="rgb(207,123,46)" fg:x="22999" fg:w="96"/><text x="59.0981%" y="287.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (906 samples, 2.32%)</title><rect x="56.7832%" y="325" width="2.3182%" height="15" fill="rgb(240,218,32)" fg:x="22192" fg:w="906"/><text x="57.0332%" y="335.50">&lt;..</text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (914 samples, 2.34%)</title><rect x="56.7755%" y="469" width="2.3387%" height="15" fill="rgb(252,5,43)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="479.50">c..</text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (914 samples, 2.34%)</title><rect x="56.7755%" y="453" width="2.3387%" height="15" fill="rgb(252,84,19)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="463.50">&lt;..</text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (914 samples, 2.34%)</title><rect x="56.7755%" y="437" width="2.3387%" height="15" fill="rgb(243,152,39)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="447.50">a..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (914 samples, 2.34%)</title><rect x="56.7755%" y="421" width="2.3387%" height="15" fill="rgb(234,160,15)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="431.50">a..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (914 samples, 2.34%)</title><rect x="56.7755%" y="405" width="2.3387%" height="15" fill="rgb(237,34,20)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="415.50">a..</text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (913 samples, 2.34%)</title><rect x="56.7781%" y="389" width="2.3361%" height="15" fill="rgb(229,97,13)" fg:x="22190" fg:w="913"/><text x="57.0281%" y="399.50">c..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (911 samples, 2.33%)</title><rect x="56.7832%" y="373" width="2.3310%" height="15" fill="rgb(234,71,50)" fg:x="22192" fg:w="911"/><text x="57.0332%" y="383.50">c..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (911 samples, 2.33%)</title><rect x="56.7832%" y="357" width="2.3310%" height="15" fill="rgb(253,155,4)" fg:x="22192" fg:w="911"/><text x="57.0332%" y="367.50">c..</text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (911 samples, 2.33%)</title><rect x="56.7832%" y="341" width="2.3310%" height="15" fill="rgb(222,185,37)" fg:x="22192" fg:w="911"/><text x="57.0332%" y="351.50">&lt;..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::current_memory (5 samples, 0.01%)</title><rect x="59.1014%" y="325" width="0.0128%" height="15" fill="rgb(251,177,13)" fg:x="23098" fg:w="5"/><text x="59.3514%" y="335.50"></text></g><g><title>std::sync::poison::Flag::done (9 samples, 0.02%)</title><rect x="59.1142%" y="437" width="0.0230%" height="15" fill="rgb(250,179,40)" fg:x="23103" fg:w="9"/><text x="59.3642%" y="447.50"></text></g><g><title>std::thread::panicking (9 samples, 0.02%)</title><rect x="59.1142%" y="421" width="0.0230%" height="15" fill="rgb(242,44,2)" fg:x="23103" fg:w="9"/><text x="59.3642%" y="431.50"></text></g><g><title>std::panicking::panicking (9 samples, 0.02%)</title><rect x="59.1142%" y="405" width="0.0230%" height="15" fill="rgb(216,177,13)" fg:x="23103" fg:w="9"/><text x="59.3642%" y="415.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (9 samples, 0.02%)</title><rect x="59.1142%" y="389" width="0.0230%" height="15" fill="rgb(216,106,43)" fg:x="23103" fg:w="9"/><text x="59.3642%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (5 samples, 0.01%)</title><rect x="59.1244%" y="373" width="0.0128%" height="15" fill="rgb(216,183,2)" fg:x="23107" fg:w="5"/><text x="59.3744%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="59.1244%" y="357" width="0.0128%" height="15" fill="rgb(249,75,3)" fg:x="23107" fg:w="5"/><text x="59.3744%" y="367.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (71 samples, 0.18%)</title><rect x="59.1142%" y="469" width="0.1817%" height="15" fill="rgb(219,67,39)" fg:x="23103" fg:w="71"/><text x="59.3642%" y="479.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (71 samples, 0.18%)</title><rect x="59.1142%" y="453" width="0.1817%" height="15" fill="rgb(253,228,2)" fg:x="23103" fg:w="71"/><text x="59.3642%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (62 samples, 0.16%)</title><rect x="59.1372%" y="437" width="0.1586%" height="15" fill="rgb(235,138,27)" fg:x="23112" fg:w="62"/><text x="59.3872%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (61 samples, 0.16%)</title><rect x="59.1398%" y="421" width="0.1561%" height="15" fill="rgb(236,97,51)" fg:x="23113" fg:w="61"/><text x="59.3898%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_swap (61 samples, 0.16%)</title><rect x="59.1398%" y="405" width="0.1561%" height="15" fill="rgb(240,80,30)" fg:x="23113" fg:w="61"/><text x="59.3898%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;std::collections::hash::map::HashMap&lt;core::num::nonzero::NonZeroU32,alloc::sync::Weak&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt;&gt;&gt; (58 samples, 0.15%)</title><rect x="59.2958%" y="469" width="0.1484%" height="15" fill="rgb(230,178,19)" fg:x="23174" fg:w="58"/><text x="59.5458%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (58 samples, 0.15%)</title><rect x="59.2958%" y="453" width="0.1484%" height="15" fill="rgb(210,190,27)" fg:x="23174" fg:w="58"/><text x="59.5458%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (58 samples, 0.15%)</title><rect x="59.2958%" y="437" width="0.1484%" height="15" fill="rgb(222,107,31)" fg:x="23174" fg:w="58"/><text x="59.5458%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (53 samples, 0.14%)</title><rect x="59.3086%" y="421" width="0.1356%" height="15" fill="rgb(216,127,34)" fg:x="23179" fg:w="53"/><text x="59.5586%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (53 samples, 0.14%)</title><rect x="59.3086%" y="405" width="0.1356%" height="15" fill="rgb(234,116,52)" fg:x="23179" fg:w="53"/><text x="59.5586%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (48 samples, 0.12%)</title><rect x="59.4442%" y="469" width="0.1228%" height="15" fill="rgb(222,124,15)" fg:x="23232" fg:w="48"/><text x="59.6942%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (48 samples, 0.12%)</title><rect x="59.4442%" y="453" width="0.1228%" height="15" fill="rgb(231,179,28)" fg:x="23232" fg:w="48"/><text x="59.6942%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (48 samples, 0.12%)</title><rect x="59.4442%" y="437" width="0.1228%" height="15" fill="rgb(226,93,45)" fg:x="23232" fg:w="48"/><text x="59.6942%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (44 samples, 0.11%)</title><rect x="59.4545%" y="421" width="0.1126%" height="15" fill="rgb(215,8,51)" fg:x="23236" fg:w="44"/><text x="59.7045%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (44 samples, 0.11%)</title><rect x="59.4545%" y="405" width="0.1126%" height="15" fill="rgb(223,106,5)" fg:x="23236" fg:w="44"/><text x="59.7045%" y="415.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (6 samples, 0.02%)</title><rect x="59.6131%" y="325" width="0.0154%" height="15" fill="rgb(250,191,5)" fg:x="23298" fg:w="6"/><text x="59.8631%" y="335.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::c_rounds (11 samples, 0.03%)</title><rect x="59.6054%" y="341" width="0.0281%" height="15" fill="rgb(242,132,44)" fg:x="23295" fg:w="11"/><text x="59.8554%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (11 samples, 0.03%)</title><rect x="59.6515%" y="325" width="0.0281%" height="15" fill="rgb(251,152,29)" fg:x="23313" fg:w="11"/><text x="59.9015%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="59.5799%" y="389" width="0.1305%" height="15" fill="rgb(218,179,5)" fg:x="23285" fg:w="51"/><text x="59.8299%" y="399.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="59.5799%" y="373" width="0.1305%" height="15" fill="rgb(227,67,19)" fg:x="23285" fg:w="51"/><text x="59.8299%" y="383.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="59.5799%" y="357" width="0.1305%" height="15" fill="rgb(233,119,31)" fg:x="23285" fg:w="51"/><text x="59.8299%" y="367.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::d_rounds (30 samples, 0.08%)</title><rect x="59.6336%" y="341" width="0.0768%" height="15" fill="rgb(241,120,22)" fg:x="23306" fg:w="30"/><text x="59.8836%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (12 samples, 0.03%)</title><rect x="59.6796%" y="325" width="0.0307%" height="15" fill="rgb(224,102,30)" fg:x="23324" fg:w="12"/><text x="59.9296%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::RandomState as core::hash::BuildHasher&gt;::build_hasher (5 samples, 0.01%)</title><rect x="59.7104%" y="389" width="0.0128%" height="15" fill="rgb(210,164,37)" fg:x="23336" fg:w="5"/><text x="59.9604%" y="399.50"></text></g><g><title>hashbrown::map::make_hash (76 samples, 0.19%)</title><rect x="59.5722%" y="421" width="0.1945%" height="15" fill="rgb(226,191,16)" fg:x="23282" fg:w="76"/><text x="59.8222%" y="431.50"></text></g><g><title>core::hash::BuildHasher::hash_one (76 samples, 0.19%)</title><rect x="59.5722%" y="405" width="0.1945%" height="15" fill="rgb(214,40,45)" fg:x="23282" fg:w="76"/><text x="59.8222%" y="415.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (17 samples, 0.04%)</title><rect x="59.7231%" y="389" width="0.0435%" height="15" fill="rgb(244,29,26)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="399.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (17 samples, 0.04%)</title><rect x="59.7231%" y="373" width="0.0435%" height="15" fill="rgb(216,16,5)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="383.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for u32&gt;::hash (17 samples, 0.04%)</title><rect x="59.7231%" y="357" width="0.0435%" height="15" fill="rgb(249,76,35)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="367.50"></text></g><g><title>core::hash::Hasher::write_u32 (17 samples, 0.04%)</title><rect x="59.7231%" y="341" width="0.0435%" height="15" fill="rgb(207,11,44)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="351.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::write (17 samples, 0.04%)</title><rect x="59.7231%" y="325" width="0.0435%" height="15" fill="rgb(228,190,49)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="335.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::write (17 samples, 0.04%)</title><rect x="59.7231%" y="309" width="0.0435%" height="15" fill="rgb(214,173,12)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="319.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::write (17 samples, 0.04%)</title><rect x="59.7231%" y="293" width="0.0435%" height="15" fill="rgb(218,26,35)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="303.50"></text></g><g><title>core::hash::sip::u8to64_le (7 samples, 0.02%)</title><rect x="59.7487%" y="277" width="0.0179%" height="15" fill="rgb(220,200,19)" fg:x="23351" fg:w="7"/><text x="59.9987%" y="287.50"></text></g><g><title>&lt;hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator&gt;::next (9 samples, 0.02%)</title><rect x="59.7820%" y="373" width="0.0230%" height="15" fill="rgb(239,95,49)" fg:x="23364" fg:w="9"/><text x="60.0320%" y="383.50"></text></g><g><title>hashbrown::raw::bitmask::BitMask::lowest_set_bit (5 samples, 0.01%)</title><rect x="59.7922%" y="357" width="0.0128%" height="15" fill="rgb(235,85,53)" fg:x="23368" fg:w="5"/><text x="60.0422%" y="367.50"></text></g><g><title>hashbrown::map::equivalent_key::_{{closure}} (7 samples, 0.02%)</title><rect x="59.8050%" y="357" width="0.0179%" height="15" fill="rgb(233,133,31)" fg:x="23373" fg:w="7"/><text x="60.0550%" y="367.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::cmp::PartialEq&gt;::eq (7 samples, 0.02%)</title><rect x="59.8050%" y="341" width="0.0179%" height="15" fill="rgb(218,25,20)" fg:x="23373" fg:w="7"/><text x="60.0550%" y="351.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find::_{{closure}} (11 samples, 0.03%)</title><rect x="59.8050%" y="373" width="0.0281%" height="15" fill="rgb(252,210,38)" fg:x="23373" fg:w="11"/><text x="60.0550%" y="383.50"></text></g><g><title>hashbrown::raw::Bucket&lt;T&gt;::as_ref (4 samples, 0.01%)</title><rect x="59.8229%" y="357" width="0.0102%" height="15" fill="rgb(242,134,21)" fg:x="23380" fg:w="4"/><text x="60.0729%" y="367.50"></text></g><g><title>hashbrown::raw::Bucket&lt;T&gt;::as_ptr (4 samples, 0.01%)</title><rect x="59.8229%" y="341" width="0.0102%" height="15" fill="rgb(213,28,48)" fg:x="23380" fg:w="4"/><text x="60.0729%" y="351.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::sub (4 samples, 0.01%)</title><rect x="59.8229%" y="325" width="0.0102%" height="15" fill="rgb(250,196,2)" fg:x="23380" fg:w="4"/><text x="60.0729%" y="335.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::offset (4 samples, 0.01%)</title><rect x="59.8229%" y="309" width="0.0102%" height="15" fill="rgb(227,5,17)" fg:x="23380" fg:w="4"/><text x="60.0729%" y="319.50"></text></g><g><title>hashbrown::raw::h2 (10 samples, 0.03%)</title><rect x="59.8332%" y="373" width="0.0256%" height="15" fill="rgb(221,226,24)" fg:x="23384" fg:w="10"/><text x="60.0832%" y="383.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (119 samples, 0.30%)</title><rect x="59.5722%" y="437" width="0.3045%" height="15" fill="rgb(211,5,48)" fg:x="23282" fg:w="119"/><text x="59.8222%" y="447.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::get (43 samples, 0.11%)</title><rect x="59.7666%" y="421" width="0.1100%" height="15" fill="rgb(219,150,6)" fg:x="23358" fg:w="43"/><text x="60.0166%" y="431.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find (43 samples, 0.11%)</title><rect x="59.7666%" y="405" width="0.1100%" height="15" fill="rgb(251,46,16)" fg:x="23358" fg:w="43"/><text x="60.0166%" y="415.50"></text></g><g><title>hashbrown::raw::RawTableInner&lt;A&gt;::find_inner (43 samples, 0.11%)</title><rect x="59.7666%" y="389" width="0.1100%" height="15" fill="rgb(220,204,40)" fg:x="23358" fg:w="43"/><text x="60.0166%" y="399.50"></text></g><g><title>hashbrown::raw::sse2::Group::match_byte (4 samples, 0.01%)</title><rect x="59.8664%" y="373" width="0.0102%" height="15" fill="rgb(211,85,2)" fg:x="23397" fg:w="4"/><text x="60.1164%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_movemask_epi8 (4 samples, 0.01%)</title><rect x="59.8664%" y="357" width="0.0102%" height="15" fill="rgb(229,17,7)" fg:x="23397" fg:w="4"/><text x="60.1164%" y="367.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (122 samples, 0.31%)</title><rect x="59.5722%" y="469" width="0.3122%" height="15" fill="rgb(239,72,28)" fg:x="23282" fg:w="122"/><text x="59.8222%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (122 samples, 0.31%)</title><rect x="59.5722%" y="453" width="0.3122%" height="15" fill="rgb(230,47,54)" fg:x="23282" fg:w="122"/><text x="59.8222%" y="463.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (8 samples, 0.02%)</title><rect x="59.8895%" y="453" width="0.0205%" height="15" fill="rgb(214,50,8)" fg:x="23406" fg:w="8"/><text x="60.1395%" y="463.50"></text></g><g><title>std::sync::poison::Flag::guard (5 samples, 0.01%)</title><rect x="59.8971%" y="437" width="0.0128%" height="15" fill="rgb(216,198,43)" fg:x="23409" fg:w="5"/><text x="60.1471%" y="447.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (47 samples, 0.12%)</title><rect x="59.8843%" y="469" width="0.1203%" height="15" fill="rgb(234,20,35)" fg:x="23404" fg:w="47"/><text x="60.1343%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (37 samples, 0.09%)</title><rect x="59.9099%" y="453" width="0.0947%" height="15" fill="rgb(254,45,19)" fg:x="23414" fg:w="37"/><text x="60.1599%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (37 samples, 0.09%)</title><rect x="59.9099%" y="437" width="0.0947%" height="15" fill="rgb(219,14,44)" fg:x="23414" fg:w="37"/><text x="60.1599%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (37 samples, 0.09%)</title><rect x="59.9099%" y="421" width="0.0947%" height="15" fill="rgb(217,220,26)" fg:x="23414" fg:w="37"/><text x="60.1599%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (108 samples, 0.28%)</title><rect x="60.0404%" y="437" width="0.2763%" height="15" fill="rgb(213,158,28)" fg:x="23465" fg:w="108"/><text x="60.2904%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (108 samples, 0.28%)</title><rect x="60.0404%" y="421" width="0.2763%" height="15" fill="rgb(252,51,52)" fg:x="23465" fg:w="108"/><text x="60.2904%" y="431.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (129 samples, 0.33%)</title><rect x="60.0046%" y="469" width="0.3301%" height="15" fill="rgb(246,89,16)" fg:x="23451" fg:w="129"/><text x="60.2546%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (129 samples, 0.33%)</title><rect x="60.0046%" y="453" width="0.3301%" height="15" fill="rgb(216,158,49)" fg:x="23451" fg:w="129"/><text x="60.2546%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::is_read_lockable (7 samples, 0.02%)</title><rect x="60.3168%" y="437" width="0.0179%" height="15" fill="rgb(236,107,19)" fg:x="23573" fg:w="7"/><text x="60.5668%" y="447.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::check (11 samples, 0.03%)</title><rect x="60.3347%" y="469" width="0.0281%" height="15" fill="rgb(228,185,30)" fg:x="23580" fg:w="11"/><text x="60.5847%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicU64::load (6 samples, 0.02%)</title><rect x="60.3475%" y="453" width="0.0154%" height="15" fill="rgb(246,134,8)" fg:x="23585" fg:w="6"/><text x="60.5975%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="60.3475%" y="437" width="0.0154%" height="15" fill="rgb(214,143,50)" fg:x="23585" fg:w="6"/><text x="60.5975%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::push (19 samples, 0.05%)</title><rect x="60.4217%" y="453" width="0.0486%" height="15" fill="rgb(228,75,8)" fg:x="23614" fg:w="19"/><text x="60.6717%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push (19 samples, 0.05%)</title><rect x="60.4217%" y="437" width="0.0486%" height="15" fill="rgb(207,175,4)" fg:x="23614" fg:w="19"/><text x="60.6717%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::try_push (19 samples, 0.05%)</title><rect x="60.4217%" y="421" width="0.0486%" height="15" fill="rgb(205,108,24)" fg:x="23614" fg:w="19"/><text x="60.6717%" y="431.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push_unchecked (13 samples, 0.03%)</title><rect x="60.4370%" y="405" width="0.0333%" height="15" fill="rgb(244,120,49)" fg:x="23620" fg:w="13"/><text x="60.6870%" y="415.50"></text></g><g><title>core::ptr::write (12 samples, 0.03%)</title><rect x="60.4396%" y="389" width="0.0307%" height="15" fill="rgb(223,47,38)" fg:x="23621" fg:w="12"/><text x="60.6896%" y="399.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init_read (4 samples, 0.01%)</title><rect x="60.4780%" y="453" width="0.0102%" height="15" fill="rgb(229,179,11)" fg:x="23636" fg:w="4"/><text x="60.7280%" y="463.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::read (4 samples, 0.01%)</title><rect x="60.4780%" y="437" width="0.0102%" height="15" fill="rgb(231,122,1)" fg:x="23636" fg:w="4"/><text x="60.7280%" y="447.50"></text></g><g><title>core::ptr::read (4 samples, 0.01%)</title><rect x="60.4780%" y="421" width="0.0102%" height="15" fill="rgb(245,119,9)" fg:x="23636" fg:w="4"/><text x="60.7280%" y="431.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init (4 samples, 0.01%)</title><rect x="60.4780%" y="405" width="0.0102%" height="15" fill="rgb(241,163,25)" fg:x="23636" fg:w="4"/><text x="60.7280%" y="415.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::write (4 samples, 0.01%)</title><rect x="60.4882%" y="453" width="0.0102%" height="15" fill="rgb(217,214,3)" fg:x="23640" fg:w="4"/><text x="60.7382%" y="463.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (5 samples, 0.01%)</title><rect x="60.5061%" y="453" width="0.0128%" height="15" fill="rgb(240,86,28)" fg:x="23647" fg:w="5"/><text x="60.7561%" y="463.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (62 samples, 0.16%)</title><rect x="60.3628%" y="469" width="0.1586%" height="15" fill="rgb(215,47,9)" fg:x="23591" fg:w="62"/><text x="60.6128%" y="479.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (26 samples, 0.07%)</title><rect x="60.5240%" y="453" width="0.0665%" height="15" fill="rgb(252,25,45)" fg:x="23654" fg:w="26"/><text x="60.7740%" y="463.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (26 samples, 0.07%)</title><rect x="60.5240%" y="437" width="0.0665%" height="15" fill="rgb(251,164,9)" fg:x="23654" fg:w="26"/><text x="60.7740%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (26 samples, 0.07%)</title><rect x="60.5240%" y="421" width="0.0665%" height="15" fill="rgb(233,194,0)" fg:x="23654" fg:w="26"/><text x="60.7740%" y="431.50"></text></g><g><title>zssp::zeta::from_nonce (31 samples, 0.08%)</title><rect x="60.5215%" y="469" width="0.0793%" height="15" fill="rgb(249,111,24)" fg:x="23653" fg:w="31"/><text x="60.7715%" y="479.50"></text></g><g><title>core::num::&lt;impl u64&gt;::from_be_bytes (4 samples, 0.01%)</title><rect x="60.5906%" y="453" width="0.0102%" height="15" fill="rgb(250,223,3)" fg:x="23680" fg:w="4"/><text x="60.8406%" y="463.50"></text></g><g><title>core::num::&lt;impl u64&gt;::from_be (4 samples, 0.01%)</title><rect x="60.5906%" y="437" width="0.0102%" height="15" fill="rgb(236,178,37)" fg:x="23680" fg:w="4"/><text x="60.8406%" y="447.50"></text></g><g><title>core::num::&lt;impl u64&gt;::swap_bytes (4 samples, 0.01%)</title><rect x="60.5906%" y="421" width="0.0102%" height="15" fill="rgb(241,158,50)" fg:x="23680" fg:w="4"/><text x="60.8406%" y="431.50"></text></g><g><title>&lt;core::slice::iter::IterMut&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::next (9 samples, 0.02%)</title><rect x="60.6417%" y="453" width="0.0230%" height="15" fill="rgb(213,121,41)" fg:x="23700" fg:w="9"/><text x="60.8917%" y="463.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (55 samples, 0.14%)</title><rect x="60.6648%" y="453" width="0.1407%" height="15" fill="rgb(240,92,3)" fg:x="23709" fg:w="55"/><text x="60.9148%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (55 samples, 0.14%)</title><rect x="60.6648%" y="437" width="0.1407%" height="15" fill="rgb(205,123,3)" fg:x="23709" fg:w="55"/><text x="60.9148%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (53 samples, 0.14%)</title><rect x="60.6699%" y="421" width="0.1356%" height="15" fill="rgb(205,97,47)" fg:x="23711" fg:w="53"/><text x="60.9199%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (53 samples, 0.14%)</title><rect x="60.6699%" y="405" width="0.1356%" height="15" fill="rgb(247,152,14)" fg:x="23711" fg:w="53"/><text x="60.9199%" y="415.50"></text></g><g><title>[libcrypto.so.3] (103 samples, 0.26%)</title><rect x="61.5552%" y="341" width="0.2635%" height="15" fill="rgb(248,195,53)" fg:x="24057" fg:w="103"/><text x="61.8052%" y="351.50"></text></g><g><title>CRYPTO_gcm128_decrypt (234 samples, 0.60%)</title><rect x="61.2328%" y="357" width="0.5987%" height="15" fill="rgb(226,201,16)" fg:x="23931" fg:w="234"/><text x="61.4828%" y="367.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="61.8187%" y="341" width="0.0128%" height="15" fill="rgb(205,98,0)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="61.8187%" y="325" width="0.0128%" height="15" fill="rgb(214,191,48)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="335.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="61.8187%" y="309" width="0.0128%" height="15" fill="rgb(237,112,39)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="61.8187%" y="293" width="0.0128%" height="15" fill="rgb(247,203,27)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="61.8187%" y="277" width="0.0128%" height="15" fill="rgb(235,124,28)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="61.8187%" y="261" width="0.0128%" height="15" fill="rgb(208,207,46)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="61.8187%" y="245" width="0.0128%" height="15" fill="rgb(234,176,4)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="61.8187%" y="229" width="0.0128%" height="15" fill="rgb(230,133,28)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="239.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="61.8187%" y="213" width="0.0128%" height="15" fill="rgb(211,137,40)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="61.8187%" y="197" width="0.0128%" height="15" fill="rgb(254,35,13)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="207.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="61.8213%" y="181" width="0.0102%" height="15" fill="rgb(225,49,51)" fg:x="24161" fg:w="4"/><text x="62.0713%" y="191.50"></text></g><g><title>[libcrypto.so.3] (17 samples, 0.04%)</title><rect x="62.9420%" y="325" width="0.0435%" height="15" fill="rgb(251,10,15)" fg:x="24599" fg:w="17"/><text x="63.1920%" y="335.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (452 samples, 1.16%)</title><rect x="61.8315%" y="357" width="1.1565%" height="15" fill="rgb(228,207,15)" fg:x="24165" fg:w="452"/><text x="62.0815%" y="367.50"></text></g><g><title>[libcrypto.so.3] (355 samples, 0.91%)</title><rect x="62.0797%" y="341" width="0.9083%" height="15" fill="rgb(241,99,19)" fg:x="24262" fg:w="355"/><text x="62.3297%" y="351.50"></text></g><g><title>CRYPTO_gcm128_setiv (15 samples, 0.04%)</title><rect x="62.9881%" y="357" width="0.0384%" height="15" fill="rgb(207,104,49)" fg:x="24617" fg:w="15"/><text x="63.2381%" y="367.50"></text></g><g><title>[libcrypto.so.3] (14 samples, 0.04%)</title><rect x="62.9906%" y="341" width="0.0358%" height="15" fill="rgb(234,99,18)" fg:x="24618" fg:w="14"/><text x="63.2406%" y="351.50"></text></g><g><title>asm_sysvec_apic_timer_interrupt (5 samples, 0.01%)</title><rect x="71.7619%" y="325" width="0.0128%" height="15" fill="rgb(213,191,49)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="335.50"></text></g><g><title>sysvec_apic_timer_interrupt (5 samples, 0.01%)</title><rect x="71.7619%" y="309" width="0.0128%" height="15" fill="rgb(210,226,19)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="71.7619%" y="293" width="0.0128%" height="15" fill="rgb(229,97,18)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="71.7619%" y="277" width="0.0128%" height="15" fill="rgb(211,167,15)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="71.7619%" y="261" width="0.0128%" height="15" fill="rgb(210,169,34)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="71.7619%" y="245" width="0.0128%" height="15" fill="rgb(241,121,31)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="71.7619%" y="229" width="0.0128%" height="15" fill="rgb(232,40,11)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="71.7619%" y="213" width="0.0128%" height="15" fill="rgb(205,86,26)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="71.7619%" y="197" width="0.0128%" height="15" fill="rgb(231,126,28)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="71.7619%" y="181" width="0.0128%" height="15" fill="rgb(219,221,18)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="191.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="71.7619%" y="165" width="0.0128%" height="15" fill="rgb(211,40,0)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="175.50"></text></g><g><title>__perf_event_task_sched_in (9 samples, 0.02%)</title><rect x="71.7747%" y="181" width="0.0230%" height="15" fill="rgb(239,85,43)" fg:x="28051" fg:w="9"/><text x="72.0247%" y="191.50"></text></g><g><title>perf_ctx_enable (9 samples, 0.02%)</title><rect x="71.7747%" y="165" width="0.0230%" height="15" fill="rgb(231,55,21)" fg:x="28051" fg:w="9"/><text x="72.0247%" y="175.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (4,297 samples, 10.99%)</title><rect x="60.8055%" y="453" width="10.9948%" height="15" fill="rgb(225,184,43)" fg:x="23764" fg:w="4297"/><text x="61.0555%" y="463.50">&lt;zssp::crypto_im..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4,297 samples, 10.99%)</title><rect x="60.8055%" y="437" width="10.9948%" height="15" fill="rgb(251,158,41)" fg:x="23764" fg:w="4297"/><text x="61.0555%" y="447.50">zssp::crypto_imp..</text></g><g><title>EVP_DecryptUpdate (4,294 samples, 10.99%)</title><rect x="60.8132%" y="421" width="10.9872%" height="15" fill="rgb(234,159,37)" fg:x="23767" fg:w="4294"/><text x="61.0632%" y="431.50">EVP_DecryptUpdate</text></g><g><title>[libcrypto.so.3] (4,195 samples, 10.73%)</title><rect x="61.0665%" y="405" width="10.7338%" height="15" fill="rgb(216,204,22)" fg:x="23866" fg:w="4195"/><text x="61.3165%" y="415.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,187 samples, 10.71%)</title><rect x="61.0869%" y="389" width="10.7134%" height="15" fill="rgb(214,17,3)" fg:x="23874" fg:w="4187"/><text x="61.3369%" y="399.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,169 samples, 10.67%)</title><rect x="61.1330%" y="373" width="10.6673%" height="15" fill="rgb(212,111,17)" fg:x="23892" fg:w="4169"/><text x="61.3830%" y="383.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,429 samples, 8.77%)</title><rect x="63.0265%" y="357" width="8.7739%" height="15" fill="rgb(221,157,24)" fg:x="24632" fg:w="3429"/><text x="63.2765%" y="367.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,280 samples, 8.39%)</title><rect x="63.4077%" y="341" width="8.3926%" height="15" fill="rgb(252,16,13)" fg:x="24781" fg:w="3280"/><text x="63.6577%" y="351.50">[libcrypto.s..</text></g><g><title>asm_sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="71.7747%" y="325" width="0.0256%" height="15" fill="rgb(221,62,2)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="71.7747%" y="309" width="0.0256%" height="15" fill="rgb(247,87,22)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="319.50"></text></g><g><title>irqentry_exit (10 samples, 0.03%)</title><rect x="71.7747%" y="293" width="0.0256%" height="15" fill="rgb(215,73,9)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (10 samples, 0.03%)</title><rect x="71.7747%" y="277" width="0.0256%" height="15" fill="rgb(207,175,33)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (10 samples, 0.03%)</title><rect x="71.7747%" y="261" width="0.0256%" height="15" fill="rgb(243,129,54)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (10 samples, 0.03%)</title><rect x="71.7747%" y="245" width="0.0256%" height="15" fill="rgb(227,119,45)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="255.50"></text></g><g><title>schedule (10 samples, 0.03%)</title><rect x="71.7747%" y="229" width="0.0256%" height="15" fill="rgb(205,109,36)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="239.50"></text></g><g><title>__schedule (10 samples, 0.03%)</title><rect x="71.7747%" y="213" width="0.0256%" height="15" fill="rgb(205,6,39)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="71.7747%" y="197" width="0.0256%" height="15" fill="rgb(221,32,16)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="207.50"></text></g><g><title>CRYPTO_clear_free (106 samples, 0.27%)</title><rect x="71.8336%" y="357" width="0.2712%" height="15" fill="rgb(228,144,50)" fg:x="28074" fg:w="106"/><text x="72.0836%" y="367.50"></text></g><g><title>OPENSSL_cleanse (103 samples, 0.26%)</title><rect x="71.8413%" y="341" width="0.2635%" height="15" fill="rgb(229,201,53)" fg:x="28077" fg:w="103"/><text x="72.0913%" y="351.50"></text></g><g><title>EVP_CIPHER_free (44 samples, 0.11%)</title><rect x="72.1099%" y="357" width="0.1126%" height="15" fill="rgb(249,153,27)" fg:x="28182" fg:w="44"/><text x="72.3599%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_free (199 samples, 0.51%)</title><rect x="71.8080%" y="389" width="0.5092%" height="15" fill="rgb(227,106,25)" fg:x="28064" fg:w="199"/><text x="72.0580%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_reset (198 samples, 0.51%)</title><rect x="71.8106%" y="373" width="0.5066%" height="15" fill="rgb(230,65,29)" fg:x="28065" fg:w="198"/><text x="72.0606%" y="383.50"></text></g><g><title>cfree (37 samples, 0.09%)</title><rect x="72.2225%" y="357" width="0.0947%" height="15" fill="rgb(221,57,46)" fg:x="28226" fg:w="37"/><text x="72.4725%" y="367.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="72.3044%" y="341" width="0.0128%" height="15" fill="rgb(229,161,17)" fg:x="28258" fg:w="5"/><text x="72.5544%" y="351.50"></text></g><g><title>cfree (9 samples, 0.02%)</title><rect x="72.3172%" y="389" width="0.0230%" height="15" fill="rgb(222,213,11)" fg:x="28263" fg:w="9"/><text x="72.5672%" y="399.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="72.3300%" y="373" width="0.0102%" height="15" fill="rgb(235,35,13)" fg:x="28268" fg:w="4"/><text x="72.5800%" y="383.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec&gt; (212 samples, 0.54%)</title><rect x="71.8003%" y="437" width="0.5424%" height="15" fill="rgb(233,158,34)" fg:x="28061" fg:w="212"/><text x="72.0503%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::CipherCtx&gt; (212 samples, 0.54%)</title><rect x="71.8003%" y="421" width="0.5424%" height="15" fill="rgb(215,151,48)" fg:x="28061" fg:w="212"/><text x="72.0503%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::CipherCtx as core::ops::drop::Drop&gt;::drop (212 samples, 0.54%)</title><rect x="71.8003%" y="405" width="0.5424%" height="15" fill="rgb(229,84,14)" fg:x="28061" fg:w="212"/><text x="72.0503%" y="415.50"></text></g><g><title>[libcrypto.so.3] (26 samples, 0.07%)</title><rect x="72.3556%" y="405" width="0.0665%" height="15" fill="rgb(229,68,14)" fg:x="28278" fg:w="26"/><text x="72.6056%" y="415.50"></text></g><g><title>[libcrypto.so.3] (26 samples, 0.07%)</title><rect x="72.3556%" y="389" width="0.0665%" height="15" fill="rgb(243,106,26)" fg:x="28278" fg:w="26"/><text x="72.6056%" y="399.50"></text></g><g><title>[libcrypto.so.3] (26 samples, 0.07%)</title><rect x="72.3556%" y="373" width="0.0665%" height="15" fill="rgb(206,45,38)" fg:x="28278" fg:w="26"/><text x="72.6056%" y="383.50"></text></g><g><title>CRYPTO_gcm128_finish (24 samples, 0.06%)</title><rect x="72.3607%" y="357" width="0.0614%" height="15" fill="rgb(226,6,15)" fg:x="28280" fg:w="24"/><text x="72.6107%" y="367.50"></text></g><g><title>[libcrypto.so.3] (18 samples, 0.05%)</title><rect x="72.3760%" y="341" width="0.0461%" height="15" fill="rgb(232,22,54)" fg:x="28286" fg:w="18"/><text x="72.6260%" y="351.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (36 samples, 0.09%)</title><rect x="72.3428%" y="437" width="0.0921%" height="15" fill="rgb(229,222,32)" fg:x="28273" fg:w="36"/><text x="72.5928%" y="447.50"></text></g><g><title>EVP_DecryptFinal_ex (36 samples, 0.09%)</title><rect x="72.3428%" y="421" width="0.0921%" height="15" fill="rgb(228,62,29)" fg:x="28273" fg:w="36"/><text x="72.5928%" y="431.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="72.4221%" y="405" width="0.0128%" height="15" fill="rgb(251,103,34)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="415.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="72.4221%" y="389" width="0.0128%" height="15" fill="rgb(233,12,30)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="399.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="72.4221%" y="373" width="0.0128%" height="15" fill="rgb(238,52,0)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="383.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="72.4221%" y="357" width="0.0128%" height="15" fill="rgb(223,98,5)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="367.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="72.4221%" y="341" width="0.0128%" height="15" fill="rgb(228,75,37)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="351.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="72.4221%" y="325" width="0.0128%" height="15" fill="rgb(205,115,49)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="335.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="72.4221%" y="309" width="0.0128%" height="15" fill="rgb(250,154,43)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="319.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="72.4221%" y="293" width="0.0128%" height="15" fill="rgb(226,43,29)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="303.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="72.4221%" y="277" width="0.0128%" height="15" fill="rgb(249,228,39)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="287.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="72.4221%" y="261" width="0.0128%" height="15" fill="rgb(216,79,43)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="271.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="72.4221%" y="245" width="0.0128%" height="15" fill="rgb(228,95,12)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="255.50"></text></g><g><title>OSSL_PARAM_get_octet_string (7 samples, 0.02%)</title><rect x="72.5577%" y="389" width="0.0179%" height="15" fill="rgb(249,221,15)" fg:x="28357" fg:w="7"/><text x="72.8077%" y="399.50"></text></g><g><title>[libcrypto.so.3] (5 samples, 0.01%)</title><rect x="72.5628%" y="373" width="0.0128%" height="15" fill="rgb(233,34,13)" fg:x="28359" fg:w="5"/><text x="72.8128%" y="383.50"></text></g><g><title>[libc.so.6] (12 samples, 0.03%)</title><rect x="72.6191%" y="373" width="0.0307%" height="15" fill="rgb(214,103,39)" fg:x="28381" fg:w="12"/><text x="72.8691%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (30 samples, 0.08%)</title><rect x="72.5756%" y="389" width="0.0768%" height="15" fill="rgb(251,126,39)" fg:x="28364" fg:w="30"/><text x="72.8256%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (336 samples, 0.86%)</title><rect x="71.8003%" y="453" width="0.8597%" height="15" fill="rgb(214,216,36)" fg:x="28061" fg:w="336"/><text x="72.0503%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::set_tag (88 samples, 0.23%)</title><rect x="72.4349%" y="437" width="0.2252%" height="15" fill="rgb(220,221,8)" fg:x="28309" fg:w="88"/><text x="72.6849%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (88 samples, 0.23%)</title><rect x="72.4349%" y="421" width="0.2252%" height="15" fill="rgb(240,216,3)" fg:x="28309" fg:w="88"/><text x="72.6849%" y="431.50"></text></g><g><title>[libcrypto.so.3] (49 samples, 0.13%)</title><rect x="72.5347%" y="405" width="0.1254%" height="15" fill="rgb(232,218,17)" fg:x="28348" fg:w="49"/><text x="72.7847%" y="415.50"></text></g><g><title>[libc.so.6] (27 samples, 0.07%)</title><rect x="72.8110%" y="389" width="0.0691%" height="15" fill="rgb(229,163,45)" fg:x="28456" fg:w="27"/><text x="73.0610%" y="399.50"></text></g><g><title>OSSL_PARAM_locate (38 samples, 0.10%)</title><rect x="72.7905%" y="405" width="0.0972%" height="15" fill="rgb(231,110,42)" fg:x="28448" fg:w="38"/><text x="73.0405%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (90 samples, 0.23%)</title><rect x="72.6652%" y="437" width="0.2303%" height="15" fill="rgb(208,170,48)" fg:x="28399" fg:w="90"/><text x="72.9152%" y="447.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="72.7598%" y="421" width="0.1356%" height="15" fill="rgb(239,116,25)" fg:x="28436" fg:w="53"/><text x="73.0098%" y="431.50"></text></g><g><title>[libc.so.6] (24 samples, 0.06%)</title><rect x="73.1078%" y="341" width="0.0614%" height="15" fill="rgb(219,200,50)" fg:x="28572" fg:w="24"/><text x="73.3578%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (48 samples, 0.12%)</title><rect x="73.0515%" y="357" width="0.1228%" height="15" fill="rgb(245,200,0)" fg:x="28550" fg:w="48"/><text x="73.3015%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (82 samples, 0.21%)</title><rect x="72.9671%" y="389" width="0.2098%" height="15" fill="rgb(245,119,33)" fg:x="28517" fg:w="82"/><text x="73.2171%" y="399.50"></text></g><g><title>[libcrypto.so.3] (60 samples, 0.15%)</title><rect x="73.0234%" y="373" width="0.1535%" height="15" fill="rgb(231,125,12)" fg:x="28539" fg:w="60"/><text x="73.2734%" y="383.50"></text></g><g><title>[libc.so.6] (18 samples, 0.05%)</title><rect x="73.2537%" y="341" width="0.0461%" height="15" fill="rgb(216,96,41)" fg:x="28629" fg:w="18"/><text x="73.5037%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (34 samples, 0.09%)</title><rect x="73.2178%" y="357" width="0.0870%" height="15" fill="rgb(248,43,45)" fg:x="28615" fg:w="34"/><text x="73.4678%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_key_length (51 samples, 0.13%)</title><rect x="73.1769%" y="389" width="0.1305%" height="15" fill="rgb(217,222,7)" fg:x="28599" fg:w="51"/><text x="73.4269%" y="399.50"></text></g><g><title>[libcrypto.so.3] (42 samples, 0.11%)</title><rect x="73.1999%" y="373" width="0.1075%" height="15" fill="rgb(233,28,6)" fg:x="28608" fg:w="42"/><text x="73.4499%" y="383.50"></text></g><g><title>CRYPTO_THREAD_read_lock (155 samples, 0.40%)</title><rect x="73.3560%" y="341" width="0.3966%" height="15" fill="rgb(231,218,15)" fg:x="28669" fg:w="155"/><text x="73.6060%" y="351.50"></text></g><g><title>pthread_rwlock_rdlock (151 samples, 0.39%)</title><rect x="73.3663%" y="325" width="0.3864%" height="15" fill="rgb(226,171,48)" fg:x="28673" fg:w="151"/><text x="73.6163%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (88 samples, 0.23%)</title><rect x="73.7629%" y="325" width="0.2252%" height="15" fill="rgb(235,201,9)" fg:x="28828" fg:w="88"/><text x="74.0129%" y="335.50"></text></g><g><title>CRYPTO_THREAD_unlock (91 samples, 0.23%)</title><rect x="73.7577%" y="341" width="0.2328%" height="15" fill="rgb(217,80,15)" fg:x="28826" fg:w="91"/><text x="74.0077%" y="351.50"></text></g><g><title>EVP_CIPHER_up_ref (29 samples, 0.07%)</title><rect x="73.9957%" y="341" width="0.0742%" height="15" fill="rgb(219,152,8)" fg:x="28919" fg:w="29"/><text x="74.2457%" y="351.50"></text></g><g><title>OPENSSL_LH_retrieve (59 samples, 0.15%)</title><rect x="74.0699%" y="341" width="0.1510%" height="15" fill="rgb(243,107,38)" fg:x="28948" fg:w="59"/><text x="74.3199%" y="351.50"></text></g><g><title>[libcrypto.so.3] (51 samples, 0.13%)</title><rect x="74.0904%" y="325" width="0.1305%" height="15" fill="rgb(231,17,5)" fg:x="28956" fg:w="51"/><text x="74.3404%" y="335.50"></text></g><g><title>pthread_rwlock_rdlock (40 samples, 0.10%)</title><rect x="74.2465%" y="309" width="0.1023%" height="15" fill="rgb(209,25,54)" fg:x="29017" fg:w="40"/><text x="74.4965%" y="319.50"></text></g><g><title>CRYPTO_THREAD_read_lock (43 samples, 0.11%)</title><rect x="74.2465%" y="325" width="0.1100%" height="15" fill="rgb(219,0,2)" fg:x="29017" fg:w="43"/><text x="74.4965%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (49 samples, 0.13%)</title><rect x="74.3667%" y="309" width="0.1254%" height="15" fill="rgb(246,9,5)" fg:x="29064" fg:w="49"/><text x="74.6167%" y="319.50"></text></g><g><title>CRYPTO_THREAD_unlock (54 samples, 0.14%)</title><rect x="74.3565%" y="325" width="0.1382%" height="15" fill="rgb(226,159,4)" fg:x="29060" fg:w="54"/><text x="74.6065%" y="335.50"></text></g><g><title>OPENSSL_strnlen (7 samples, 0.02%)</title><rect x="74.5074%" y="309" width="0.0179%" height="15" fill="rgb(219,175,34)" fg:x="29119" fg:w="7"/><text x="74.7574%" y="319.50"></text></g><g><title>CRYPTO_strndup (15 samples, 0.04%)</title><rect x="74.5023%" y="325" width="0.0384%" height="15" fill="rgb(236,10,46)" fg:x="29117" fg:w="15"/><text x="74.7523%" y="335.50"></text></g><g><title>OPENSSL_strcasecmp (25 samples, 0.06%)</title><rect x="74.7531%" y="293" width="0.0640%" height="15" fill="rgb(240,211,16)" fg:x="29215" fg:w="25"/><text x="75.0031%" y="303.50"></text></g><g><title>OPENSSL_LH_retrieve (150 samples, 0.38%)</title><rect x="74.5407%" y="325" width="0.3838%" height="15" fill="rgb(205,3,43)" fg:x="29132" fg:w="150"/><text x="74.7907%" y="335.50"></text></g><g><title>[libcrypto.so.3] (142 samples, 0.36%)</title><rect x="74.5612%" y="309" width="0.3633%" height="15" fill="rgb(245,7,22)" fg:x="29140" fg:w="142"/><text x="74.8112%" y="319.50"></text></g><g><title>[libcrypto.so.3] (42 samples, 0.11%)</title><rect x="74.8171%" y="293" width="0.1075%" height="15" fill="rgb(239,132,32)" fg:x="29240" fg:w="42"/><text x="75.0671%" y="303.50"></text></g><g><title>[libcrypto.so.3] (298 samples, 0.76%)</title><rect x="74.2234%" y="341" width="0.7625%" height="15" fill="rgb(228,202,34)" fg:x="29008" fg:w="298"/><text x="74.4734%" y="351.50"></text></g><g><title>cfree (23 samples, 0.06%)</title><rect x="74.9271%" y="325" width="0.0589%" height="15" fill="rgb(254,200,22)" fg:x="29283" fg:w="23"/><text x="75.1771%" y="335.50"></text></g><g><title>[libc.so.6] (6 samples, 0.02%)</title><rect x="74.9706%" y="309" width="0.0154%" height="15" fill="rgb(219,10,39)" fg:x="29300" fg:w="6"/><text x="75.2206%" y="319.50"></text></g><g><title>[libcrypto.so.3] (652 samples, 1.67%)</title><rect x="73.3253%" y="357" width="1.6683%" height="15" fill="rgb(226,210,39)" fg:x="28657" fg:w="652"/><text x="73.5753%" y="367.50"></text></g><g><title>EVP_CIPHER_fetch (660 samples, 1.69%)</title><rect x="73.3074%" y="389" width="1.6888%" height="15" fill="rgb(208,219,16)" fg:x="28650" fg:w="660"/><text x="73.5574%" y="399.50"></text></g><g><title>[libcrypto.so.3] (658 samples, 1.68%)</title><rect x="73.3125%" y="373" width="1.6836%" height="15" fill="rgb(216,158,51)" fg:x="28652" fg:w="658"/><text x="73.5625%" y="383.50"></text></g><g><title>EVP_CIPHER_free (15 samples, 0.04%)</title><rect x="74.9962%" y="389" width="0.0384%" height="15" fill="rgb(233,14,44)" fg:x="29310" fg:w="15"/><text x="75.2462%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (14 samples, 0.04%)</title><rect x="75.0345%" y="389" width="0.0358%" height="15" fill="rgb(237,97,39)" fg:x="29325" fg:w="14"/><text x="75.2845%" y="399.50"></text></g><g><title>CRYPTO_malloc (4 samples, 0.01%)</title><rect x="75.1036%" y="357" width="0.0102%" height="15" fill="rgb(218,198,43)" fg:x="29352" fg:w="4"/><text x="75.3536%" y="367.50"></text></g><g><title>[libc.so.6] (8 samples, 0.02%)</title><rect x="75.1139%" y="357" width="0.0205%" height="15" fill="rgb(231,104,20)" fg:x="29356" fg:w="8"/><text x="75.3639%" y="367.50"></text></g><g><title>malloc (7 samples, 0.02%)</title><rect x="75.1343%" y="357" width="0.0179%" height="15" fill="rgb(254,36,13)" fg:x="29364" fg:w="7"/><text x="75.3843%" y="367.50"></text></g><g><title>CRYPTO_zalloc (21 samples, 0.05%)</title><rect x="75.1011%" y="373" width="0.0537%" height="15" fill="rgb(248,14,50)" fg:x="29351" fg:w="21"/><text x="75.3511%" y="383.50"></text></g><g><title>CRYPTO_gcm128_init (149 samples, 0.38%)</title><rect x="75.1702%" y="357" width="0.3812%" height="15" fill="rgb(217,107,29)" fg:x="29378" fg:w="149"/><text x="75.4202%" y="367.50"></text></g><g><title>[libcrypto.so.3] (122 samples, 0.31%)</title><rect x="75.2392%" y="341" width="0.3122%" height="15" fill="rgb(251,169,33)" fg:x="29405" fg:w="122"/><text x="75.4892%" y="351.50"></text></g><g><title>[libcrypto.so.3] (188 samples, 0.48%)</title><rect x="75.1574%" y="373" width="0.4810%" height="15" fill="rgb(217,108,32)" fg:x="29373" fg:w="188"/><text x="75.4074%" y="383.50"></text></g><g><title>[libcrypto.so.3] (34 samples, 0.09%)</title><rect x="75.5514%" y="357" width="0.0870%" height="15" fill="rgb(219,66,42)" fg:x="29527" fg:w="34"/><text x="75.8014%" y="367.50"></text></g><g><title>EVP_CipherInit_ex (1,072 samples, 2.74%)</title><rect x="72.8980%" y="421" width="2.7430%" height="15" fill="rgb(206,180,7)" fg:x="28490" fg:w="1072"/><text x="73.1480%" y="431.50">EV..</text></g><g><title>[libcrypto.so.3] (1,072 samples, 2.74%)</title><rect x="72.8980%" y="405" width="2.7430%" height="15" fill="rgb(208,226,31)" fg:x="28490" fg:w="1072"/><text x="73.1480%" y="415.50">[l..</text></g><g><title>[libcrypto.so.3] (221 samples, 0.57%)</title><rect x="75.0755%" y="389" width="0.5655%" height="15" fill="rgb(218,26,49)" fg:x="29341" fg:w="221"/><text x="75.3255%" y="399.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (1,074 samples, 2.75%)</title><rect x="72.8955%" y="437" width="2.7481%" height="15" fill="rgb(233,197,48)" fg:x="28489" fg:w="1074"/><text x="73.1455%" y="447.50">zs..</text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="75.6486%" y="405" width="0.0102%" height="15" fill="rgb(252,181,51)" fg:x="29565" fg:w="4"/><text x="75.8986%" y="415.50"></text></g><g><title>malloc (15 samples, 0.04%)</title><rect x="75.6589%" y="405" width="0.0384%" height="15" fill="rgb(253,90,19)" fg:x="29569" fg:w="15"/><text x="75.9089%" y="415.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (1,188 samples, 3.04%)</title><rect x="72.6600%" y="453" width="3.0398%" height="15" fill="rgb(215,171,30)" fg:x="28397" fg:w="1188"/><text x="72.9100%" y="463.50">&lt;zs..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::new (22 samples, 0.06%)</title><rect x="75.6435%" y="437" width="0.0563%" height="15" fill="rgb(214,222,9)" fg:x="29563" fg:w="22"/><text x="75.8935%" y="447.50"></text></g><g><title>CRYPTO_zalloc (22 samples, 0.06%)</title><rect x="75.6435%" y="421" width="0.0563%" height="15" fill="rgb(223,3,22)" fg:x="29563" fg:w="22"/><text x="75.8935%" y="431.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::Index&lt;I&gt; for [T]&gt;::index (5 samples, 0.01%)</title><rect x="75.7024%" y="453" width="0.0128%" height="15" fill="rgb(225,196,46)" fg:x="29586" fg:w="5"/><text x="75.9524%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index (5 samples, 0.01%)</title><rect x="75.7024%" y="437" width="0.0128%" height="15" fill="rgb(209,110,37)" fg:x="29586" fg:w="5"/><text x="75.9524%" y="447.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (4 samples, 0.01%)</title><rect x="75.7049%" y="421" width="0.0102%" height="15" fill="rgb(249,89,12)" fg:x="29587" fg:w="4"/><text x="75.9549%" y="431.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (4 samples, 0.01%)</title><rect x="75.7049%" y="405" width="0.0102%" height="15" fill="rgb(226,27,33)" fg:x="29587" fg:w="4"/><text x="75.9549%" y="415.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::add (4 samples, 0.01%)</title><rect x="75.7049%" y="389" width="0.0102%" height="15" fill="rgb(213,82,22)" fg:x="29587" fg:w="4"/><text x="75.9549%" y="399.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::offset (4 samples, 0.01%)</title><rect x="75.7049%" y="373" width="0.0102%" height="15" fill="rgb(248,140,0)" fg:x="29587" fg:w="4"/><text x="75.9549%" y="383.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (6 samples, 0.02%)</title><rect x="75.7152%" y="453" width="0.0154%" height="15" fill="rgb(228,106,3)" fg:x="29591" fg:w="6"/><text x="75.9652%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (6 samples, 0.02%)</title><rect x="75.7152%" y="437" width="0.0154%" height="15" fill="rgb(209,23,37)" fg:x="29591" fg:w="6"/><text x="75.9652%" y="447.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (183 samples, 0.47%)</title><rect x="75.7305%" y="453" width="0.4682%" height="15" fill="rgb(241,93,50)" fg:x="29597" fg:w="183"/><text x="75.9805%" y="463.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (183 samples, 0.47%)</title><rect x="75.7305%" y="437" width="0.4682%" height="15" fill="rgb(253,46,43)" fg:x="29597" fg:w="183"/><text x="75.9805%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (181 samples, 0.46%)</title><rect x="75.7356%" y="421" width="0.4631%" height="15" fill="rgb(226,206,43)" fg:x="29599" fg:w="181"/><text x="75.9856%" y="431.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (181 samples, 0.46%)</title><rect x="75.7356%" y="405" width="0.4631%" height="15" fill="rgb(217,54,7)" fg:x="29599" fg:w="181"/><text x="75.9856%" y="415.50"></text></g><g><title>[libc.so.6] (181 samples, 0.46%)</title><rect x="75.7356%" y="389" width="0.4631%" height="15" fill="rgb(223,5,52)" fg:x="29599" fg:w="181"/><text x="75.9856%" y="399.50"></text></g><g><title>zssp::zeta::receive_payload_in_place (6,109 samples, 15.63%)</title><rect x="60.6008%" y="469" width="15.6312%" height="15" fill="rgb(206,52,46)" fg:x="23684" fg:w="6109"/><text x="60.8508%" y="479.50">zssp::zeta::receive_payl..</text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::update (13 samples, 0.03%)</title><rect x="76.1988%" y="453" width="0.0333%" height="15" fill="rgb(253,136,11)" fg:x="29780" fg:w="13"/><text x="76.4488%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_max (13 samples, 0.03%)</title><rect x="76.1988%" y="437" width="0.0333%" height="15" fill="rgb(208,106,33)" fg:x="29780" fg:w="13"/><text x="76.4488%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_umax (13 samples, 0.03%)</title><rect x="76.1988%" y="421" width="0.0333%" height="15" fill="rgb(206,54,4)" fg:x="29780" fg:w="13"/><text x="76.4488%" y="431.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8,570 samples, 21.93%)</title><rect x="54.5034%" y="485" width="21.9283%" height="15" fill="rgb(213,3,15)" fg:x="21301" fg:w="8570"/><text x="54.7534%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::receive</text></g><g><title>zssp::zssp::parse_fragment_header (78 samples, 0.20%)</title><rect x="76.2320%" y="469" width="0.1996%" height="15" fill="rgb(252,211,39)" fg:x="29793" fg:w="78"/><text x="76.4820%" y="479.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (6 samples, 0.02%)</title><rect x="76.4163%" y="453" width="0.0154%" height="15" fill="rgb(223,6,36)" fg:x="29865" fg:w="6"/><text x="76.6663%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (6 samples, 0.02%)</title><rect x="76.4163%" y="437" width="0.0154%" height="15" fill="rgb(252,169,45)" fg:x="29865" fg:w="6"/><text x="76.6663%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (60 samples, 0.15%)</title><rect x="76.5237%" y="437" width="0.1535%" height="15" fill="rgb(212,48,26)" fg:x="29907" fg:w="60"/><text x="76.7737%" y="447.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (60 samples, 0.15%)</title><rect x="76.5237%" y="421" width="0.1535%" height="15" fill="rgb(251,102,48)" fg:x="29907" fg:w="60"/><text x="76.7737%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (58 samples, 0.15%)</title><rect x="76.5288%" y="405" width="0.1484%" height="15" fill="rgb(243,208,16)" fg:x="29909" fg:w="58"/><text x="76.7788%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (53 samples, 0.14%)</title><rect x="76.5416%" y="389" width="0.1356%" height="15" fill="rgb(219,96,24)" fg:x="29914" fg:w="53"/><text x="76.7916%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_swap (53 samples, 0.14%)</title><rect x="76.5416%" y="373" width="0.1356%" height="15" fill="rgb(219,33,29)" fg:x="29914" fg:w="53"/><text x="76.7916%" y="383.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (4 samples, 0.01%)</title><rect x="76.6772%" y="421" width="0.0102%" height="15" fill="rgb(223,176,5)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="431.50"></text></g><g><title>std::sync::poison::Flag::guard (4 samples, 0.01%)</title><rect x="76.6772%" y="405" width="0.0102%" height="15" fill="rgb(228,140,14)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="415.50"></text></g><g><title>std::thread::panicking (4 samples, 0.01%)</title><rect x="76.6772%" y="389" width="0.0102%" height="15" fill="rgb(217,179,31)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="399.50"></text></g><g><title>std::panicking::panicking (4 samples, 0.01%)</title><rect x="76.6772%" y="373" width="0.0102%" height="15" fill="rgb(230,9,30)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="383.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (4 samples, 0.01%)</title><rect x="76.6772%" y="357" width="0.0102%" height="15" fill="rgb(230,136,20)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="367.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (90 samples, 0.23%)</title><rect x="76.6772%" y="437" width="0.2303%" height="15" fill="rgb(215,210,22)" fg:x="29967" fg:w="90"/><text x="76.9272%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (86 samples, 0.22%)</title><rect x="76.6875%" y="421" width="0.2201%" height="15" fill="rgb(218,43,5)" fg:x="29971" fg:w="86"/><text x="76.9375%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (80 samples, 0.20%)</title><rect x="76.7028%" y="405" width="0.2047%" height="15" fill="rgb(216,11,5)" fg:x="29977" fg:w="80"/><text x="76.9528%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (80 samples, 0.20%)</title><rect x="76.7028%" y="389" width="0.2047%" height="15" fill="rgb(209,82,29)" fg:x="29977" fg:w="80"/><text x="76.9528%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (337 samples, 0.86%)</title><rect x="76.5160%" y="453" width="0.8623%" height="15" fill="rgb(244,115,12)" fg:x="29904" fg:w="337"/><text x="76.7660%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (184 samples, 0.47%)</title><rect x="76.9075%" y="437" width="0.4708%" height="15" fill="rgb(222,82,18)" fg:x="30057" fg:w="184"/><text x="77.1575%" y="447.50"></text></g><g><title>EVP_EncryptUpdate (183 samples, 0.47%)</title><rect x="76.9101%" y="421" width="0.4682%" height="15" fill="rgb(249,227,8)" fg:x="30058" fg:w="183"/><text x="77.1601%" y="431.50"></text></g><g><title>[libcrypto.so.3] (160 samples, 0.41%)</title><rect x="76.9689%" y="405" width="0.4094%" height="15" fill="rgb(253,141,45)" fg:x="30081" fg:w="160"/><text x="77.2189%" y="415.50"></text></g><g><title>[libcrypto.so.3] (121 samples, 0.31%)</title><rect x="77.0687%" y="389" width="0.3096%" height="15" fill="rgb(234,184,4)" fg:x="30120" fg:w="121"/><text x="77.3187%" y="399.50"></text></g><g><title>[libcrypto.so.3] (116 samples, 0.30%)</title><rect x="77.0815%" y="373" width="0.2968%" height="15" fill="rgb(218,194,23)" fg:x="30125" fg:w="116"/><text x="77.3315%" y="383.50"></text></g><g><title>CRYPTO_gcm128_encrypt (243 samples, 0.62%)</title><rect x="77.7340%" y="357" width="0.6218%" height="15" fill="rgb(235,66,41)" fg:x="30380" fg:w="243"/><text x="77.9840%" y="367.50"></text></g><g><title>[libcrypto.so.3] (137 samples, 0.35%)</title><rect x="78.0052%" y="341" width="0.3505%" height="15" fill="rgb(245,217,1)" fg:x="30486" fg:w="137"/><text x="78.2552%" y="351.50"></text></g><g><title>[libcrypto.so.3] (326 samples, 0.83%)</title><rect x="78.6500%" y="341" width="0.8341%" height="15" fill="rgb(229,91,1)" fg:x="30738" fg:w="326"/><text x="78.9000%" y="351.50"></text></g><g><title>[libcrypto.so.3] (21 samples, 0.05%)</title><rect x="79.4304%" y="325" width="0.0537%" height="15" fill="rgb(207,101,30)" fg:x="31043" fg:w="21"/><text x="79.6804%" y="335.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (442 samples, 1.13%)</title><rect x="78.3558%" y="357" width="1.1310%" height="15" fill="rgb(223,82,49)" fg:x="30623" fg:w="442"/><text x="78.6058%" y="367.50"></text></g><g><title>CRYPTO_gcm128_setiv (16 samples, 0.04%)</title><rect x="79.4867%" y="357" width="0.0409%" height="15" fill="rgb(218,167,17)" fg:x="31065" fg:w="16"/><text x="79.7367%" y="367.50"></text></g><g><title>[libcrypto.so.3] (15 samples, 0.04%)</title><rect x="79.4893%" y="341" width="0.0384%" height="15" fill="rgb(208,103,14)" fg:x="31066" fg:w="15"/><text x="79.7393%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (3,402 samples, 8.70%)</title><rect x="77.3783%" y="453" width="8.7048%" height="15" fill="rgb(238,20,8)" fg:x="30241" fg:w="3402"/><text x="77.6283%" y="463.50">&lt;zssp::crypt..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (3,400 samples, 8.70%)</title><rect x="77.3835%" y="437" width="8.6997%" height="15" fill="rgb(218,80,54)" fg:x="30243" fg:w="3400"/><text x="77.6335%" y="447.50">zssp::crypto..</text></g><g><title>EVP_EncryptUpdate (3,399 samples, 8.70%)</title><rect x="77.3860%" y="421" width="8.6971%" height="15" fill="rgb(240,144,17)" fg:x="30244" fg:w="3399"/><text x="77.6360%" y="431.50">EVP_EncryptU..</text></g><g><title>[libcrypto.so.3] (3,327 samples, 8.51%)</title><rect x="77.5702%" y="405" width="8.5129%" height="15" fill="rgb(245,27,50)" fg:x="30316" fg:w="3327"/><text x="77.8202%" y="415.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,322 samples, 8.50%)</title><rect x="77.5830%" y="389" width="8.5001%" height="15" fill="rgb(251,51,7)" fg:x="30321" fg:w="3322"/><text x="77.8330%" y="399.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,300 samples, 8.44%)</title><rect x="77.6393%" y="373" width="8.4438%" height="15" fill="rgb(245,217,29)" fg:x="30343" fg:w="3300"/><text x="77.8893%" y="383.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (2,562 samples, 6.56%)</title><rect x="79.5277%" y="357" width="6.5554%" height="15" fill="rgb(221,176,29)" fg:x="31081" fg:w="2562"/><text x="79.7777%" y="367.50">[libcrypt..</text></g><g><title>[libcrypto.so.3] (2,334 samples, 5.97%)</title><rect x="80.1110%" y="341" width="5.9721%" height="15" fill="rgb(212,180,24)" fg:x="31309" fg:w="2334"/><text x="80.3610%" y="351.50">[libcryp..</text></g><g><title>CRYPTO_clear_free (96 samples, 0.25%)</title><rect x="86.1394%" y="357" width="0.2456%" height="15" fill="rgb(254,24,2)" fg:x="33665" fg:w="96"/><text x="86.3894%" y="367.50"></text></g><g><title>OPENSSL_cleanse (96 samples, 0.25%)</title><rect x="86.1394%" y="341" width="0.2456%" height="15" fill="rgb(230,100,2)" fg:x="33665" fg:w="96"/><text x="86.3894%" y="351.50"></text></g><g><title>EVP_CIPHER_free (43 samples, 0.11%)</title><rect x="86.3876%" y="357" width="0.1100%" height="15" fill="rgb(219,142,25)" fg:x="33762" fg:w="43"/><text x="86.6376%" y="367.50"></text></g><g><title>cfree (23 samples, 0.06%)</title><rect x="86.5002%" y="357" width="0.0589%" height="15" fill="rgb(240,73,43)" fg:x="33806" fg:w="23"/><text x="86.7502%" y="367.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="86.5462%" y="341" width="0.0128%" height="15" fill="rgb(214,114,15)" fg:x="33824" fg:w="5"/><text x="86.7962%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_free (185 samples, 0.47%)</title><rect x="86.0882%" y="389" width="0.4734%" height="15" fill="rgb(207,130,4)" fg:x="33645" fg:w="185"/><text x="86.3382%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_reset (185 samples, 0.47%)</title><rect x="86.0882%" y="373" width="0.4734%" height="15" fill="rgb(221,25,40)" fg:x="33645" fg:w="185"/><text x="86.3382%" y="383.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc&gt; (191 samples, 0.49%)</title><rect x="86.0857%" y="437" width="0.4887%" height="15" fill="rgb(241,184,7)" fg:x="33644" fg:w="191"/><text x="86.3357%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::CipherCtx&gt; (191 samples, 0.49%)</title><rect x="86.0857%" y="421" width="0.4887%" height="15" fill="rgb(235,159,4)" fg:x="33644" fg:w="191"/><text x="86.3357%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::CipherCtx as core::ops::drop::Drop&gt;::drop (191 samples, 0.49%)</title><rect x="86.0857%" y="405" width="0.4887%" height="15" fill="rgb(214,87,48)" fg:x="33644" fg:w="191"/><text x="86.3357%" y="415.50"></text></g><g><title>cfree (5 samples, 0.01%)</title><rect x="86.5616%" y="389" width="0.0128%" height="15" fill="rgb(246,198,24)" fg:x="33830" fg:w="5"/><text x="86.8116%" y="399.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="86.5641%" y="373" width="0.0102%" height="15" fill="rgb(209,66,40)" fg:x="33831" fg:w="4"/><text x="86.8141%" y="383.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (69 samples, 0.18%)</title><rect x="86.5744%" y="437" width="0.1766%" height="15" fill="rgb(233,147,39)" fg:x="33835" fg:w="69"/><text x="86.8244%" y="447.50"></text></g><g><title>EVP_EncryptFinal_ex (67 samples, 0.17%)</title><rect x="86.5795%" y="421" width="0.1714%" height="15" fill="rgb(231,145,52)" fg:x="33837" fg:w="67"/><text x="86.8295%" y="431.50"></text></g><g><title>[libcrypto.so.3] (51 samples, 0.13%)</title><rect x="86.6204%" y="405" width="0.1305%" height="15" fill="rgb(206,20,26)" fg:x="33853" fg:w="51"/><text x="86.8704%" y="415.50"></text></g><g><title>[libcrypto.so.3] (50 samples, 0.13%)</title><rect x="86.6230%" y="389" width="0.1279%" height="15" fill="rgb(238,220,4)" fg:x="33854" fg:w="50"/><text x="86.8730%" y="399.50"></text></g><g><title>[libcrypto.so.3] (45 samples, 0.12%)</title><rect x="86.6358%" y="373" width="0.1151%" height="15" fill="rgb(252,195,42)" fg:x="33859" fg:w="45"/><text x="86.8858%" y="383.50"></text></g><g><title>CRYPTO_gcm128_tag (45 samples, 0.12%)</title><rect x="86.6358%" y="357" width="0.1151%" height="15" fill="rgb(209,10,6)" fg:x="33859" fg:w="45"/><text x="86.8858%" y="367.50"></text></g><g><title>CRYPTO_gcm128_finish (37 samples, 0.09%)</title><rect x="86.6563%" y="341" width="0.0947%" height="15" fill="rgb(229,3,52)" fg:x="33867" fg:w="37"/><text x="86.9063%" y="351.50"></text></g><g><title>[libcrypto.so.3] (22 samples, 0.06%)</title><rect x="86.6946%" y="325" width="0.0563%" height="15" fill="rgb(253,49,37)" fg:x="33882" fg:w="22"/><text x="86.9446%" y="335.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="86.9147%" y="373" width="0.0384%" height="15" fill="rgb(240,103,49)" fg:x="33968" fg:w="15"/><text x="87.1647%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (39 samples, 0.10%)</title><rect x="86.8584%" y="389" width="0.0998%" height="15" fill="rgb(250,182,30)" fg:x="33946" fg:w="39"/><text x="87.1084%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::finish (345 samples, 0.88%)</title><rect x="86.0831%" y="453" width="0.8828%" height="15" fill="rgb(248,8,30)" fg:x="33643" fg:w="345"/><text x="86.3331%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::get_tag (84 samples, 0.21%)</title><rect x="86.7509%" y="437" width="0.2149%" height="15" fill="rgb(237,120,30)" fg:x="33904" fg:w="84"/><text x="87.0009%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (83 samples, 0.21%)</title><rect x="86.7535%" y="421" width="0.2124%" height="15" fill="rgb(221,146,34)" fg:x="33905" fg:w="83"/><text x="87.0035%" y="431.50"></text></g><g><title>[libcrypto.so.3] (51 samples, 0.13%)</title><rect x="86.8354%" y="405" width="0.1305%" height="15" fill="rgb(242,55,13)" fg:x="33937" fg:w="51"/><text x="87.0854%" y="415.50"></text></g><g><title>[libc.so.6] (25 samples, 0.06%)</title><rect x="87.0861%" y="389" width="0.0640%" height="15" fill="rgb(242,112,31)" fg:x="34035" fg:w="25"/><text x="87.3361%" y="399.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.1373%" y="373" width="0.0128%" height="15" fill="rgb(249,192,27)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="383.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.1373%" y="357" width="0.0128%" height="15" fill="rgb(208,204,44)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="367.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="87.1373%" y="341" width="0.0128%" height="15" fill="rgb(208,93,54)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="351.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="87.1373%" y="325" width="0.0128%" height="15" fill="rgb(242,1,31)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="335.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="87.1373%" y="309" width="0.0128%" height="15" fill="rgb(241,83,25)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="319.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="87.1373%" y="293" width="0.0128%" height="15" fill="rgb(205,169,50)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="303.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="87.1373%" y="277" width="0.0128%" height="15" fill="rgb(239,186,37)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="287.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="87.1373%" y="261" width="0.0128%" height="15" fill="rgb(205,221,10)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="271.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="87.1373%" y="245" width="0.0128%" height="15" fill="rgb(218,196,15)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="255.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="87.1373%" y="229" width="0.0128%" height="15" fill="rgb(218,196,35)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="239.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="87.1373%" y="213" width="0.0128%" height="15" fill="rgb(233,63,24)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="223.50"></text></g><g><title>OSSL_PARAM_locate (41 samples, 0.10%)</title><rect x="87.0554%" y="405" width="0.1049%" height="15" fill="rgb(225,8,4)" fg:x="34023" fg:w="41"/><text x="87.3054%" y="415.50"></text></g><g><title>strcmp@plt (4 samples, 0.01%)</title><rect x="87.1501%" y="389" width="0.0102%" height="15" fill="rgb(234,105,35)" fg:x="34060" fg:w="4"/><text x="87.4001%" y="399.50"></text></g><g><title>[libcrypto.so.3] (49 samples, 0.13%)</title><rect x="87.0401%" y="421" width="0.1254%" height="15" fill="rgb(236,21,32)" fg:x="34017" fg:w="49"/><text x="87.2901%" y="431.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="87.1654%" y="277" width="0.0128%" height="15" fill="rgb(228,109,6)" fg:x="34066" fg:w="5"/><text x="87.4154%" y="287.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="87.1654%" y="261" width="0.0128%" height="15" fill="rgb(229,215,31)" fg:x="34066" fg:w="5"/><text x="87.4154%" y="271.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (83 samples, 0.21%)</title><rect x="86.9684%" y="437" width="0.2124%" height="15" fill="rgb(221,52,54)" fg:x="33989" fg:w="83"/><text x="87.2184%" y="447.50"></text></g><g><title>asm_sysvec_reschedule_ipi (6 samples, 0.02%)</title><rect x="87.1654%" y="421" width="0.0154%" height="15" fill="rgb(252,129,43)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="431.50"></text></g><g><title>sysvec_reschedule_ipi (6 samples, 0.02%)</title><rect x="87.1654%" y="405" width="0.0154%" height="15" fill="rgb(248,183,27)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="415.50"></text></g><g><title>irqentry_exit (6 samples, 0.02%)</title><rect x="87.1654%" y="389" width="0.0154%" height="15" fill="rgb(250,0,22)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="399.50"></text></g><g><title>irqentry_exit_to_user_mode (6 samples, 0.02%)</title><rect x="87.1654%" y="373" width="0.0154%" height="15" fill="rgb(213,166,10)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="383.50"></text></g><g><title>exit_to_user_mode_prepare (6 samples, 0.02%)</title><rect x="87.1654%" y="357" width="0.0154%" height="15" fill="rgb(207,163,36)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="367.50"></text></g><g><title>exit_to_user_mode_loop (6 samples, 0.02%)</title><rect x="87.1654%" y="341" width="0.0154%" height="15" fill="rgb(208,122,22)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="351.50"></text></g><g><title>schedule (6 samples, 0.02%)</title><rect x="87.1654%" y="325" width="0.0154%" height="15" fill="rgb(207,104,49)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="335.50"></text></g><g><title>__schedule (6 samples, 0.02%)</title><rect x="87.1654%" y="309" width="0.0154%" height="15" fill="rgb(248,211,50)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="319.50"></text></g><g><title>finish_task_switch.isra.0 (6 samples, 0.02%)</title><rect x="87.1654%" y="293" width="0.0154%" height="15" fill="rgb(217,13,45)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="303.50"></text></g><g><title>[libc.so.6] (21 samples, 0.05%)</title><rect x="87.4136%" y="341" width="0.0537%" height="15" fill="rgb(211,216,49)" fg:x="34163" fg:w="21"/><text x="87.6636%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (41 samples, 0.10%)</title><rect x="87.3676%" y="357" width="0.1049%" height="15" fill="rgb(221,58,53)" fg:x="34145" fg:w="41"/><text x="87.6176%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (82 samples, 0.21%)</title><rect x="87.2652%" y="389" width="0.2098%" height="15" fill="rgb(220,112,41)" fg:x="34105" fg:w="82"/><text x="87.5152%" y="399.50"></text></g><g><title>[libcrypto.so.3] (54 samples, 0.14%)</title><rect x="87.3369%" y="373" width="0.1382%" height="15" fill="rgb(236,38,28)" fg:x="34133" fg:w="54"/><text x="87.5869%" y="383.50"></text></g><g><title>[libc.so.6] (9 samples, 0.02%)</title><rect x="87.5646%" y="341" width="0.0230%" height="15" fill="rgb(227,195,22)" fg:x="34222" fg:w="9"/><text x="87.8146%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (26 samples, 0.07%)</title><rect x="87.5288%" y="357" width="0.0665%" height="15" fill="rgb(214,55,33)" fg:x="34208" fg:w="26"/><text x="87.7788%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_key_length (48 samples, 0.12%)</title><rect x="87.4751%" y="389" width="0.1228%" height="15" fill="rgb(248,80,13)" fg:x="34187" fg:w="48"/><text x="87.7251%" y="399.50"></text></g><g><title>[libcrypto.so.3] (40 samples, 0.10%)</title><rect x="87.4955%" y="373" width="0.1023%" height="15" fill="rgb(238,52,6)" fg:x="34195" fg:w="40"/><text x="87.7455%" y="383.50"></text></g><g><title>CRYPTO_THREAD_read_lock (116 samples, 0.30%)</title><rect x="87.6414%" y="341" width="0.2968%" height="15" fill="rgb(224,198,47)" fg:x="34252" fg:w="116"/><text x="87.8914%" y="351.50"></text></g><g><title>pthread_rwlock_rdlock (112 samples, 0.29%)</title><rect x="87.6516%" y="325" width="0.2866%" height="15" fill="rgb(233,171,20)" fg:x="34256" fg:w="112"/><text x="87.9016%" y="335.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.9254%" y="309" width="0.0128%" height="15" fill="rgb(241,30,25)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="319.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.9254%" y="293" width="0.0128%" height="15" fill="rgb(207,171,38)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="303.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="87.9254%" y="277" width="0.0128%" height="15" fill="rgb(234,70,1)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="287.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="87.9254%" y="261" width="0.0128%" height="15" fill="rgb(232,178,18)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="271.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="87.9254%" y="245" width="0.0128%" height="15" fill="rgb(241,78,40)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="255.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="87.9254%" y="229" width="0.0128%" height="15" fill="rgb(222,35,25)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="239.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="87.9254%" y="213" width="0.0128%" height="15" fill="rgb(207,92,16)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="223.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="87.9254%" y="197" width="0.0128%" height="15" fill="rgb(216,59,51)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="207.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="87.9254%" y="181" width="0.0128%" height="15" fill="rgb(213,80,28)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="191.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="87.9254%" y="165" width="0.0128%" height="15" fill="rgb(220,93,7)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="175.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="87.9254%" y="149" width="0.0128%" height="15" fill="rgb(225,24,44)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="159.50"></text></g><g><title>pthread_rwlock_unlock (95 samples, 0.24%)</title><rect x="87.9535%" y="325" width="0.2431%" height="15" fill="rgb(243,74,40)" fg:x="34374" fg:w="95"/><text x="88.2035%" y="335.50"></text></g><g><title>asm_sysvec_reschedule_ipi (4 samples, 0.01%)</title><rect x="88.1864%" y="309" width="0.0102%" height="15" fill="rgb(228,39,7)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="319.50"></text></g><g><title>sysvec_reschedule_ipi (4 samples, 0.01%)</title><rect x="88.1864%" y="293" width="0.0102%" height="15" fill="rgb(227,79,8)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="303.50"></text></g><g><title>irqentry_exit (4 samples, 0.01%)</title><rect x="88.1864%" y="277" width="0.0102%" height="15" fill="rgb(236,58,11)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="287.50"></text></g><g><title>irqentry_exit_to_user_mode (4 samples, 0.01%)</title><rect x="88.1864%" y="261" width="0.0102%" height="15" fill="rgb(249,63,35)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="271.50"></text></g><g><title>exit_to_user_mode_prepare (4 samples, 0.01%)</title><rect x="88.1864%" y="245" width="0.0102%" height="15" fill="rgb(252,114,16)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="255.50"></text></g><g><title>exit_to_user_mode_loop (4 samples, 0.01%)</title><rect x="88.1864%" y="229" width="0.0102%" height="15" fill="rgb(254,151,24)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="239.50"></text></g><g><title>schedule (4 samples, 0.01%)</title><rect x="88.1864%" y="213" width="0.0102%" height="15" fill="rgb(253,54,39)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="223.50"></text></g><g><title>__schedule (4 samples, 0.01%)</title><rect x="88.1864%" y="197" width="0.0102%" height="15" fill="rgb(243,25,45)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="207.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="88.1864%" y="181" width="0.0102%" height="15" fill="rgb(234,134,9)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="191.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="88.1864%" y="165" width="0.0102%" height="15" fill="rgb(227,166,31)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="175.50"></text></g><g><title>perf_pmu_nop_void (4 samples, 0.01%)</title><rect x="88.1864%" y="149" width="0.0102%" height="15" fill="rgb(245,143,41)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="159.50"></text></g><g><title>CRYPTO_THREAD_unlock (101 samples, 0.26%)</title><rect x="87.9433%" y="341" width="0.2584%" height="15" fill="rgb(238,181,32)" fg:x="34370" fg:w="101"/><text x="88.1933%" y="351.50"></text></g><g><title>EVP_CIPHER_up_ref (39 samples, 0.10%)</title><rect x="88.2017%" y="341" width="0.0998%" height="15" fill="rgb(224,113,18)" fg:x="34471" fg:w="39"/><text x="88.4517%" y="351.50"></text></g><g><title>OPENSSL_LH_retrieve (56 samples, 0.14%)</title><rect x="88.3015%" y="341" width="0.1433%" height="15" fill="rgb(240,229,28)" fg:x="34510" fg:w="56"/><text x="88.5515%" y="351.50"></text></g><g><title>[libcrypto.so.3] (48 samples, 0.12%)</title><rect x="88.3220%" y="325" width="0.1228%" height="15" fill="rgb(250,185,3)" fg:x="34518" fg:w="48"/><text x="88.5720%" y="335.50"></text></g><g><title>[libcrypto.so.3] (6 samples, 0.02%)</title><rect x="88.4295%" y="309" width="0.0154%" height="15" fill="rgb(212,59,25)" fg:x="34560" fg:w="6"/><text x="88.6795%" y="319.50"></text></g><g><title>pthread_rwlock_rdlock (20 samples, 0.05%)</title><rect x="88.4602%" y="309" width="0.0512%" height="15" fill="rgb(221,87,20)" fg:x="34572" fg:w="20"/><text x="88.7102%" y="319.50"></text></g><g><title>CRYPTO_THREAD_read_lock (24 samples, 0.06%)</title><rect x="88.4576%" y="325" width="0.0614%" height="15" fill="rgb(213,74,28)" fg:x="34571" fg:w="24"/><text x="88.7076%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (51 samples, 0.13%)</title><rect x="88.5267%" y="309" width="0.1305%" height="15" fill="rgb(224,132,34)" fg:x="34598" fg:w="51"/><text x="88.7767%" y="319.50"></text></g><g><title>CRYPTO_THREAD_unlock (54 samples, 0.14%)</title><rect x="88.5241%" y="325" width="0.1382%" height="15" fill="rgb(222,101,24)" fg:x="34597" fg:w="54"/><text x="88.7741%" y="335.50"></text></g><g><title>CRYPTO_strndup (10 samples, 0.03%)</title><rect x="88.6725%" y="325" width="0.0256%" height="15" fill="rgb(254,142,4)" fg:x="34655" fg:w="10"/><text x="88.9225%" y="335.50"></text></g><g><title>malloc (6 samples, 0.02%)</title><rect x="88.6828%" y="309" width="0.0154%" height="15" fill="rgb(230,229,49)" fg:x="34659" fg:w="6"/><text x="88.9328%" y="319.50"></text></g><g><title>OPENSSL_strcasecmp (44 samples, 0.11%)</title><rect x="88.8926%" y="293" width="0.1126%" height="15" fill="rgb(238,70,47)" fg:x="34741" fg:w="44"/><text x="89.1426%" y="303.50"></text></g><g><title>OPENSSL_LH_retrieve (173 samples, 0.44%)</title><rect x="88.6981%" y="325" width="0.4427%" height="15" fill="rgb(231,160,17)" fg:x="34665" fg:w="173"/><text x="88.9481%" y="335.50"></text></g><g><title>[libcrypto.so.3] (157 samples, 0.40%)</title><rect x="88.7391%" y="309" width="0.4017%" height="15" fill="rgb(218,68,53)" fg:x="34681" fg:w="157"/><text x="88.9891%" y="319.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="89.0052%" y="293" width="0.1356%" height="15" fill="rgb(236,111,10)" fg:x="34785" fg:w="53"/><text x="89.2552%" y="303.50"></text></g><g><title>cfree (17 samples, 0.04%)</title><rect x="89.1408%" y="325" width="0.0435%" height="15" fill="rgb(224,34,41)" fg:x="34838" fg:w="17"/><text x="89.3908%" y="335.50"></text></g><g><title>[libc.so.6] (6 samples, 0.02%)</title><rect x="89.1689%" y="309" width="0.0154%" height="15" fill="rgb(241,118,19)" fg:x="34849" fg:w="6"/><text x="89.4189%" y="319.50"></text></g><g><title>[libcrypto.so.3] (290 samples, 0.74%)</title><rect x="88.4448%" y="341" width="0.7420%" height="15" fill="rgb(238,129,25)" fg:x="34566" fg:w="290"/><text x="88.6948%" y="351.50"></text></g><g><title>EVP_CIPHER_fetch (622 samples, 1.59%)</title><rect x="87.5979%" y="389" width="1.5915%" height="15" fill="rgb(238,22,31)" fg:x="34235" fg:w="622"/><text x="87.8479%" y="399.50"></text></g><g><title>[libcrypto.so.3] (620 samples, 1.59%)</title><rect x="87.6030%" y="373" width="1.5864%" height="15" fill="rgb(222,174,48)" fg:x="34237" fg:w="620"/><text x="87.8530%" y="383.50"></text></g><g><title>[libcrypto.so.3] (612 samples, 1.57%)</title><rect x="87.6235%" y="357" width="1.5659%" height="15" fill="rgb(206,152,40)" fg:x="34245" fg:w="612"/><text x="87.8735%" y="367.50"></text></g><g><title>EVP_CIPHER_free (14 samples, 0.04%)</title><rect x="89.1894%" y="389" width="0.0358%" height="15" fill="rgb(218,99,54)" fg:x="34857" fg:w="14"/><text x="89.4394%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (18 samples, 0.05%)</title><rect x="89.2252%" y="389" width="0.0461%" height="15" fill="rgb(220,174,26)" fg:x="34871" fg:w="18"/><text x="89.4752%" y="399.50"></text></g><g><title>CRYPTO_malloc (4 samples, 0.01%)</title><rect x="89.2943%" y="357" width="0.0102%" height="15" fill="rgb(245,116,9)" fg:x="34898" fg:w="4"/><text x="89.5443%" y="367.50"></text></g><g><title>[libc.so.6] (9 samples, 0.02%)</title><rect x="89.3045%" y="357" width="0.0230%" height="15" fill="rgb(209,72,35)" fg:x="34902" fg:w="9"/><text x="89.5545%" y="367.50"></text></g><g><title>malloc (8 samples, 0.02%)</title><rect x="89.3276%" y="357" width="0.0205%" height="15" fill="rgb(226,126,21)" fg:x="34911" fg:w="8"/><text x="89.5776%" y="367.50"></text></g><g><title>CRYPTO_zalloc (24 samples, 0.06%)</title><rect x="89.2917%" y="373" width="0.0614%" height="15" fill="rgb(227,192,1)" fg:x="34897" fg:w="24"/><text x="89.5417%" y="383.50"></text></g><g><title>OPENSSL_init_crypto (4 samples, 0.01%)</title><rect x="89.3532%" y="373" width="0.0102%" height="15" fill="rgb(237,180,29)" fg:x="34921" fg:w="4"/><text x="89.6032%" y="383.50"></text></g><g><title>CRYPTO_gcm128_init (157 samples, 0.40%)</title><rect x="89.3685%" y="357" width="0.4017%" height="15" fill="rgb(230,197,35)" fg:x="34927" fg:w="157"/><text x="89.6185%" y="367.50"></text></g><g><title>[libcrypto.so.3] (141 samples, 0.36%)</title><rect x="89.4094%" y="341" width="0.3608%" height="15" fill="rgb(246,193,31)" fg:x="34943" fg:w="141"/><text x="89.6594%" y="351.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="89.8675%" y="213" width="0.0102%" height="15" fill="rgb(241,36,4)" fg:x="35122" fg:w="4"/><text x="90.1175%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="89.8675%" y="197" width="0.0102%" height="15" fill="rgb(241,130,17)" fg:x="35122" fg:w="4"/><text x="90.1175%" y="207.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="89.8675%" y="181" width="0.0102%" height="15" fill="rgb(206,137,32)" fg:x="35122" fg:w="4"/><text x="90.1175%" y="191.50"></text></g><g><title>EVP_CipherInit_ex (1,051 samples, 2.69%)</title><rect x="87.1910%" y="421" width="2.6892%" height="15" fill="rgb(237,228,51)" fg:x="34076" fg:w="1051"/><text x="87.4410%" y="431.50">EV..</text></g><g><title>[libcrypto.so.3] (1,051 samples, 2.69%)</title><rect x="87.1910%" y="405" width="2.6892%" height="15" fill="rgb(243,6,42)" fg:x="34076" fg:w="1051"/><text x="87.4410%" y="415.50">[l..</text></g><g><title>[libcrypto.so.3] (235 samples, 0.60%)</title><rect x="89.2790%" y="389" width="0.6013%" height="15" fill="rgb(251,74,28)" fg:x="34892" fg:w="235"/><text x="89.5290%" y="399.50"></text></g><g><title>[libcrypto.so.3] (202 samples, 0.52%)</title><rect x="89.3634%" y="373" width="0.5169%" height="15" fill="rgb(218,20,49)" fg:x="34925" fg:w="202"/><text x="89.6134%" y="383.50"></text></g><g><title>[libcrypto.so.3] (43 samples, 0.11%)</title><rect x="89.7702%" y="357" width="0.1100%" height="15" fill="rgb(238,28,14)" fg:x="35084" fg:w="43"/><text x="90.0202%" y="367.50"></text></g><g><title>asm_sysvec_reschedule_ipi (6 samples, 0.02%)</title><rect x="89.8649%" y="341" width="0.0154%" height="15" fill="rgb(229,40,46)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (6 samples, 0.02%)</title><rect x="89.8649%" y="325" width="0.0154%" height="15" fill="rgb(244,195,20)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="335.50"></text></g><g><title>irqentry_exit (6 samples, 0.02%)</title><rect x="89.8649%" y="309" width="0.0154%" height="15" fill="rgb(253,56,35)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (6 samples, 0.02%)</title><rect x="89.8649%" y="293" width="0.0154%" height="15" fill="rgb(210,149,44)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (6 samples, 0.02%)</title><rect x="89.8649%" y="277" width="0.0154%" height="15" fill="rgb(240,135,12)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (6 samples, 0.02%)</title><rect x="89.8649%" y="261" width="0.0154%" height="15" fill="rgb(251,24,50)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="89.8675%" y="245" width="0.0128%" height="15" fill="rgb(243,200,47)" fg:x="35122" fg:w="5"/><text x="90.1175%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="89.8675%" y="229" width="0.0128%" height="15" fill="rgb(224,166,26)" fg:x="35122" fg:w="5"/><text x="90.1175%" y="239.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (1,054 samples, 2.70%)</title><rect x="87.1859%" y="437" width="2.6969%" height="15" fill="rgb(233,0,47)" fg:x="34074" fg:w="1054"/><text x="87.4359%" y="447.50">zs..</text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="89.8854%" y="405" width="0.0102%" height="15" fill="rgb(253,80,5)" fg:x="35129" fg:w="4"/><text x="90.1354%" y="415.50"></text></g><g><title>malloc (7 samples, 0.02%)</title><rect x="89.8956%" y="405" width="0.0179%" height="15" fill="rgb(214,133,25)" fg:x="35133" fg:w="7"/><text x="90.1456%" y="415.50"></text></g><g><title>CRYPTO_zalloc (13 samples, 0.03%)</title><rect x="89.8828%" y="421" width="0.0333%" height="15" fill="rgb(209,27,14)" fg:x="35128" fg:w="13"/><text x="90.1328%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (1,154 samples, 2.95%)</title><rect x="86.9659%" y="453" width="2.9528%" height="15" fill="rgb(219,102,51)" fg:x="33988" fg:w="1154"/><text x="87.2159%" y="463.50">&lt;zs..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::new (14 samples, 0.04%)</title><rect x="89.8828%" y="437" width="0.0358%" height="15" fill="rgb(237,18,16)" fg:x="35128" fg:w="14"/><text x="90.1328%" y="447.50"></text></g><g><title>__rdl_alloc (6 samples, 0.02%)</title><rect x="89.9238%" y="277" width="0.0154%" height="15" fill="rgb(241,85,17)" fg:x="35144" fg:w="6"/><text x="90.1738%" y="287.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::alloc (6 samples, 0.02%)</title><rect x="89.9238%" y="261" width="0.0154%" height="15" fill="rgb(236,90,42)" fg:x="35144" fg:w="6"/><text x="90.1738%" y="271.50"></text></g><g><title>[libc.so.6] (49 samples, 0.13%)</title><rect x="93.4804%" y="245" width="0.1254%" height="15" fill="rgb(249,57,21)" fg:x="36534" fg:w="49"/><text x="93.7304%" y="255.50"></text></g><g><title>[libc.so.6] (850 samples, 2.17%)</title><rect x="91.4436%" y="261" width="2.1749%" height="15" fill="rgb(243,12,36)" fg:x="35738" fg:w="850"/><text x="91.6936%" y="271.50">[..</text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="93.6058%" y="245" width="0.0128%" height="15" fill="rgb(253,128,47)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="255.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="93.6058%" y="229" width="0.0128%" height="15" fill="rgb(207,33,20)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="239.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="93.6058%" y="213" width="0.0128%" height="15" fill="rgb(233,215,35)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="223.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="93.6058%" y="197" width="0.0128%" height="15" fill="rgb(249,188,52)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="93.6058%" y="181" width="0.0128%" height="15" fill="rgb(225,12,32)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="191.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="93.6058%" y="165" width="0.0128%" height="15" fill="rgb(247,98,14)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="175.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="93.6058%" y="149" width="0.0128%" height="15" fill="rgb(247,219,48)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="159.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="93.6058%" y="133" width="0.0128%" height="15" fill="rgb(253,60,48)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="93.6058%" y="117" width="0.0128%" height="15" fill="rgb(245,15,52)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="93.6058%" y="101" width="0.0128%" height="15" fill="rgb(220,133,28)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="111.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="93.6058%" y="85" width="0.0128%" height="15" fill="rgb(217,180,4)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="95.50"></text></g><g><title>__get_user_nocheck_4 (8 samples, 0.02%)</title><rect x="93.6800%" y="149" width="0.0205%" height="15" fill="rgb(251,24,1)" fg:x="36612" fg:w="8"/><text x="93.9300%" y="159.50"></text></g><g><title>futex_q_lock (13 samples, 0.03%)</title><rect x="93.7004%" y="149" width="0.0333%" height="15" fill="rgb(212,185,49)" fg:x="36620" fg:w="13"/><text x="93.9504%" y="159.50"></text></g><g><title>futex_q_unlock (5 samples, 0.01%)</title><rect x="93.7337%" y="149" width="0.0128%" height="15" fill="rgb(215,175,22)" fg:x="36633" fg:w="5"/><text x="93.9837%" y="159.50"></text></g><g><title>__x64_sys_futex (35 samples, 0.09%)</title><rect x="93.6620%" y="213" width="0.0896%" height="15" fill="rgb(250,205,14)" fg:x="36605" fg:w="35"/><text x="93.9120%" y="223.50"></text></g><g><title>do_futex (33 samples, 0.08%)</title><rect x="93.6672%" y="197" width="0.0844%" height="15" fill="rgb(225,211,22)" fg:x="36607" fg:w="33"/><text x="93.9172%" y="207.50"></text></g><g><title>futex_wait (32 samples, 0.08%)</title><rect x="93.6697%" y="181" width="0.0819%" height="15" fill="rgb(251,179,42)" fg:x="36608" fg:w="32"/><text x="93.9197%" y="191.50"></text></g><g><title>futex_wait_setup (28 samples, 0.07%)</title><rect x="93.6800%" y="165" width="0.0716%" height="15" fill="rgb(208,216,51)" fg:x="36612" fg:w="28"/><text x="93.9300%" y="175.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (37 samples, 0.09%)</title><rect x="93.6620%" y="245" width="0.0947%" height="15" fill="rgb(235,36,11)" fg:x="36605" fg:w="37"/><text x="93.9120%" y="255.50"></text></g><g><title>do_syscall_64 (37 samples, 0.09%)</title><rect x="93.6620%" y="229" width="0.0947%" height="15" fill="rgb(213,189,28)" fg:x="36605" fg:w="37"/><text x="93.9120%" y="239.50"></text></g><g><title>__lll_lock_wait_private (55 samples, 0.14%)</title><rect x="93.6185%" y="261" width="0.1407%" height="15" fill="rgb(227,203,42)" fg:x="36588" fg:w="55"/><text x="93.8685%" y="271.50"></text></g><g><title>futex_wake_mark (11 samples, 0.03%)</title><rect x="93.9179%" y="165" width="0.0281%" height="15" fill="rgb(244,72,36)" fg:x="36705" fg:w="11"/><text x="94.1679%" y="175.50"></text></g><g><title>wake_q_add_safe (4 samples, 0.01%)</title><rect x="93.9461%" y="165" width="0.0102%" height="15" fill="rgb(213,53,17)" fg:x="36716" fg:w="4"/><text x="94.1961%" y="175.50"></text></g><g><title>call_function_single_prep_ipi (4 samples, 0.01%)</title><rect x="94.0459%" y="101" width="0.0102%" height="15" fill="rgb(207,167,3)" fg:x="36755" fg:w="4"/><text x="94.2959%" y="111.50"></text></g><g><title>__smp_call_single_queue (17 samples, 0.04%)</title><rect x="94.0459%" y="117" width="0.0435%" height="15" fill="rgb(216,98,30)" fg:x="36755" fg:w="17"/><text x="94.2959%" y="127.50"></text></g><g><title>native_send_call_func_single_ipi (13 samples, 0.03%)</title><rect x="94.0561%" y="101" width="0.0333%" height="15" fill="rgb(236,123,15)" fg:x="36759" fg:w="13"/><text x="94.3061%" y="111.50"></text></g><g><title>x2apic_send_IPI (12 samples, 0.03%)</title><rect x="94.0586%" y="85" width="0.0307%" height="15" fill="rgb(248,81,50)" fg:x="36760" fg:w="12"/><text x="94.3086%" y="95.50"></text></g><g><title>native_write_msr (10 samples, 0.03%)</title><rect x="94.0638%" y="69" width="0.0256%" height="15" fill="rgb(214,120,4)" fg:x="36762" fg:w="10"/><text x="94.3138%" y="79.50"></text></g><g><title>llist_add_batch (10 samples, 0.03%)</title><rect x="94.0894%" y="117" width="0.0256%" height="15" fill="rgb(208,179,34)" fg:x="36772" fg:w="10"/><text x="94.3394%" y="127.50"></text></g><g><title>futex_wake (123 samples, 0.31%)</title><rect x="93.8028%" y="181" width="0.3147%" height="15" fill="rgb(227,140,7)" fg:x="36660" fg:w="123"/><text x="94.0528%" y="191.50"></text></g><g><title>wake_up_q (63 samples, 0.16%)</title><rect x="93.9563%" y="165" width="0.1612%" height="15" fill="rgb(214,22,6)" fg:x="36720" fg:w="63"/><text x="94.2063%" y="175.50"></text></g><g><title>try_to_wake_up (58 samples, 0.15%)</title><rect x="93.9691%" y="149" width="0.1484%" height="15" fill="rgb(207,137,27)" fg:x="36725" fg:w="58"/><text x="94.2191%" y="159.50"></text></g><g><title>ttwu_queue_wakelist (38 samples, 0.10%)</title><rect x="94.0203%" y="133" width="0.0972%" height="15" fill="rgb(210,8,46)" fg:x="36745" fg:w="38"/><text x="94.2703%" y="143.50"></text></g><g><title>__x64_sys_futex (133 samples, 0.34%)</title><rect x="93.7797%" y="213" width="0.3403%" height="15" fill="rgb(240,16,54)" fg:x="36651" fg:w="133"/><text x="94.0297%" y="223.50"></text></g><g><title>do_futex (132 samples, 0.34%)</title><rect x="93.7823%" y="197" width="0.3378%" height="15" fill="rgb(211,209,29)" fg:x="36652" fg:w="132"/><text x="94.0323%" y="207.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (145 samples, 0.37%)</title><rect x="93.7746%" y="245" width="0.3710%" height="15" fill="rgb(226,228,24)" fg:x="36649" fg:w="145"/><text x="94.0246%" y="255.50"></text></g><g><title>do_syscall_64 (144 samples, 0.37%)</title><rect x="93.7772%" y="229" width="0.3685%" height="15" fill="rgb(222,84,9)" fg:x="36650" fg:w="144"/><text x="94.0272%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (7 samples, 0.02%)</title><rect x="94.1277%" y="213" width="0.0179%" height="15" fill="rgb(234,203,30)" fg:x="36787" fg:w="7"/><text x="94.3777%" y="223.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="94.1328%" y="197" width="0.0128%" height="15" fill="rgb(238,109,14)" fg:x="36789" fg:w="5"/><text x="94.3828%" y="207.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (1,653 samples, 4.23%)</title><rect x="89.9186%" y="373" width="4.2296%" height="15" fill="rgb(233,206,34)" fg:x="35142" fg:w="1653"/><text x="90.1686%" y="383.50">alloc..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (1,653 samples, 4.23%)</title><rect x="89.9186%" y="357" width="4.2296%" height="15" fill="rgb(220,167,47)" fg:x="35142" fg:w="1653"/><text x="90.1686%" y="367.50">alloc..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (1,653 samples, 4.23%)</title><rect x="89.9186%" y="341" width="4.2296%" height="15" fill="rgb(238,105,10)" fg:x="35142" fg:w="1653"/><text x="90.1686%" y="351.50">alloc..</text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (1,651 samples, 4.22%)</title><rect x="89.9238%" y="325" width="4.2245%" height="15" fill="rgb(213,227,17)" fg:x="35144" fg:w="1651"/><text x="90.1738%" y="335.50">&lt;allo..</text></g><g><title>alloc::alloc::Global::alloc_impl (1,651 samples, 4.22%)</title><rect x="89.9238%" y="309" width="4.2245%" height="15" fill="rgb(217,132,38)" fg:x="35144" fg:w="1651"/><text x="90.1738%" y="319.50">alloc..</text></g><g><title>alloc::alloc::alloc (1,651 samples, 4.22%)</title><rect x="89.9238%" y="293" width="4.2245%" height="15" fill="rgb(242,146,4)" fg:x="35144" fg:w="1651"/><text x="90.1738%" y="303.50">alloc..</text></g><g><title>malloc (1,644 samples, 4.21%)</title><rect x="89.9417%" y="277" width="4.2065%" height="15" fill="rgb(212,61,9)" fg:x="35151" fg:w="1644"/><text x="90.1917%" y="287.50">malloc</text></g><g><title>__lll_lock_wake_private (152 samples, 0.39%)</title><rect x="93.7593%" y="261" width="0.3889%" height="15" fill="rgb(247,126,22)" fg:x="36643" fg:w="152"/><text x="94.0093%" y="271.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (1,857 samples, 4.75%)</title><rect x="89.9186%" y="437" width="4.7515%" height="15" fill="rgb(220,196,2)" fg:x="35142" fg:w="1857"/><text x="90.1686%" y="447.50">alloc:..</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (1,857 samples, 4.75%)</title><rect x="89.9186%" y="421" width="4.7515%" height="15" fill="rgb(208,46,4)" fg:x="35142" fg:w="1857"/><text x="90.1686%" y="431.50">alloc:..</text></g><g><title>alloc::slice::hack::to_vec (1,857 samples, 4.75%)</title><rect x="89.9186%" y="405" width="4.7515%" height="15" fill="rgb(252,104,46)" fg:x="35142" fg:w="1857"/><text x="90.1686%" y="415.50">alloc:..</text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (1,857 samples, 4.75%)</title><rect x="89.9186%" y="389" width="4.7515%" height="15" fill="rgb(237,152,48)" fg:x="35142" fg:w="1857"/><text x="90.1686%" y="399.50">&lt;T as ..</text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (204 samples, 0.52%)</title><rect x="94.1482%" y="373" width="0.5220%" height="15" fill="rgb(221,59,37)" fg:x="36795" fg:w="204"/><text x="94.3982%" y="383.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (204 samples, 0.52%)</title><rect x="94.1482%" y="357" width="0.5220%" height="15" fill="rgb(209,202,51)" fg:x="36795" fg:w="204"/><text x="94.3982%" y="367.50"></text></g><g><title>[libc.so.6] (203 samples, 0.52%)</title><rect x="94.1508%" y="341" width="0.5194%" height="15" fill="rgb(228,81,30)" fg:x="36796" fg:w="203"/><text x="94.4008%" y="351.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="97.9556%" y="405" width="0.0128%" height="15" fill="rgb(227,42,39)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="415.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="97.9556%" y="389" width="0.0128%" height="15" fill="rgb(221,26,2)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="399.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="97.9556%" y="373" width="0.0128%" height="15" fill="rgb(254,61,31)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="383.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="97.9556%" y="357" width="0.0128%" height="15" fill="rgb(222,173,38)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="367.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="97.9556%" y="341" width="0.0128%" height="15" fill="rgb(218,50,12)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="351.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="97.9556%" y="325" width="0.0128%" height="15" fill="rgb(223,88,40)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="335.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="97.9556%" y="309" width="0.0128%" height="15" fill="rgb(237,54,19)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="319.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="97.9556%" y="293" width="0.0128%" height="15" fill="rgb(251,129,25)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="303.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="97.9556%" y="277" width="0.0128%" height="15" fill="rgb(238,97,19)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="287.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="97.9556%" y="261" width="0.0128%" height="15" fill="rgb(240,169,18)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="271.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="97.9556%" y="245" width="0.0128%" height="15" fill="rgb(230,187,49)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="255.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (100 samples, 0.26%)</title><rect x="98.0707%" y="373" width="0.2559%" height="15" fill="rgb(209,44,26)" fg:x="38328" fg:w="100"/><text x="98.3207%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (100 samples, 0.26%)</title><rect x="98.0707%" y="357" width="0.2559%" height="15" fill="rgb(244,0,6)" fg:x="38328" fg:w="100"/><text x="98.3207%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (155 samples, 0.40%)</title><rect x="98.0119%" y="389" width="0.3966%" height="15" fill="rgb(248,18,21)" fg:x="38305" fg:w="155"/><text x="98.2619%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (32 samples, 0.08%)</title><rect x="98.3266%" y="373" width="0.0819%" height="15" fill="rgb(245,180,19)" fg:x="38428" fg:w="32"/><text x="98.5766%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (32 samples, 0.08%)</title><rect x="98.3266%" y="357" width="0.0819%" height="15" fill="rgb(252,118,36)" fg:x="38428" fg:w="32"/><text x="98.5766%" y="367.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::write (4 samples, 0.01%)</title><rect x="98.4136%" y="373" width="0.0102%" height="15" fill="rgb(210,224,19)" fg:x="38462" fg:w="4"/><text x="98.6636%" y="383.50"></text></g><g><title>core::ptr::write (4 samples, 0.01%)</title><rect x="98.4136%" y="357" width="0.0102%" height="15" fill="rgb(218,30,24)" fg:x="38462" fg:w="4"/><text x="98.6636%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (185 samples, 0.47%)</title><rect x="97.9684%" y="405" width="0.4734%" height="15" fill="rgb(219,75,50)" fg:x="38288" fg:w="185"/><text x="98.2184%" y="415.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (13 samples, 0.03%)</title><rect x="98.4085%" y="389" width="0.0333%" height="15" fill="rgb(234,72,50)" fg:x="38460" fg:w="13"/><text x="98.6585%" y="399.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (7 samples, 0.02%)</title><rect x="98.4238%" y="373" width="0.0179%" height="15" fill="rgb(219,100,48)" fg:x="38466" fg:w="7"/><text x="98.6738%" y="383.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (5 samples, 0.01%)</title><rect x="98.4289%" y="357" width="0.0128%" height="15" fill="rgb(253,5,41)" fg:x="38468" fg:w="5"/><text x="98.6789%" y="367.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="98.4289%" y="341" width="0.0128%" height="15" fill="rgb(247,181,11)" fg:x="38468" fg:w="5"/><text x="98.6789%" y="351.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (3,332 samples, 8.53%)</title><rect x="89.9186%" y="453" width="8.5257%" height="15" fill="rgb(222,223,25)" fg:x="35142" fg:w="3332"/><text x="90.1686%" y="463.50">benchmark::b..</text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (1,474 samples, 3.77%)</title><rect x="94.6727%" y="437" width="3.7716%" height="15" fill="rgb(214,198,28)" fg:x="37000" fg:w="1474"/><text x="94.9227%" y="447.50">std:..</text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (1,473 samples, 3.77%)</title><rect x="94.6753%" y="421" width="3.7690%" height="15" fill="rgb(230,46,43)" fg:x="37001" fg:w="1473"/><text x="94.9253%" y="431.50">std:..</text></g><g><title>core::mem::drop (27 samples, 0.07%)</title><rect x="98.4520%" y="453" width="0.0691%" height="15" fill="rgb(233,65,53)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (27 samples, 0.07%)</title><rect x="98.4520%" y="437" width="0.0691%" height="15" fill="rgb(221,121,27)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="447.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (27 samples, 0.07%)</title><rect x="98.4520%" y="421" width="0.0691%" height="15" fill="rgb(247,70,47)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (27 samples, 0.07%)</title><rect x="98.4520%" y="405" width="0.0691%" height="15" fill="rgb(228,85,35)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (27 samples, 0.07%)</title><rect x="98.4520%" y="389" width="0.0691%" height="15" fill="rgb(209,50,18)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_sub (27 samples, 0.07%)</title><rect x="98.4520%" y="373" width="0.0691%" height="15" fill="rgb(250,19,35)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="383.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (7 samples, 0.02%)</title><rect x="98.5211%" y="453" width="0.0179%" height="15" fill="rgb(253,107,29)" fg:x="38504" fg:w="7"/><text x="98.7711%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (7 samples, 0.02%)</title><rect x="98.5211%" y="437" width="0.0179%" height="15" fill="rgb(252,179,29)" fg:x="38504" fg:w="7"/><text x="98.7711%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (35 samples, 0.09%)</title><rect x="98.5492%" y="421" width="0.0896%" height="15" fill="rgb(238,194,6)" fg:x="38515" fg:w="35"/><text x="98.7992%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (35 samples, 0.09%)</title><rect x="98.5492%" y="405" width="0.0896%" height="15" fill="rgb(238,164,29)" fg:x="38515" fg:w="35"/><text x="98.7992%" y="415.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (36 samples, 0.09%)</title><rect x="98.5492%" y="453" width="0.0921%" height="15" fill="rgb(224,25,9)" fg:x="38515" fg:w="36"/><text x="98.7992%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (36 samples, 0.09%)</title><rect x="98.5492%" y="437" width="0.0921%" height="15" fill="rgb(244,153,23)" fg:x="38515" fg:w="36"/><text x="98.7992%" y="447.50"></text></g><g><title>benchmark::bob_main (18,132 samples, 46.39%)</title><rect x="52.2773%" y="501" width="46.3948%" height="15" fill="rgb(212,203,14)" fg:x="20431" fg:w="18132"/><text x="52.5273%" y="511.50">benchmark::bob_main</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::send (8,692 samples, 22.24%)</title><rect x="76.4316%" y="485" width="22.2404%" height="15" fill="rgb(220,164,20)" fg:x="29871" fg:w="8692"/><text x="76.6816%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::send</text></g><g><title>zssp::zeta::send_payload (8,691 samples, 22.24%)</title><rect x="76.4342%" y="469" width="22.2379%" height="15" fill="rgb(222,203,48)" fg:x="29872" fg:w="8691"/><text x="76.6842%" y="479.50">zssp::zeta::send_payload</text></g><g><title>zssp::zeta::get_counter (12 samples, 0.03%)</title><rect x="98.6413%" y="453" width="0.0307%" height="15" fill="rgb(215,159,22)" fg:x="38551" fg:w="12"/><text x="98.8913%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_add (11 samples, 0.03%)</title><rect x="98.6439%" y="437" width="0.0281%" height="15" fill="rgb(216,183,47)" fg:x="38552" fg:w="11"/><text x="98.8939%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_add (11 samples, 0.03%)</title><rect x="98.6439%" y="421" width="0.0281%" height="15" fill="rgb(229,195,25)" fg:x="38552" fg:w="11"/><text x="98.8939%" y="431.50"></text></g><g><title>cfree (19 samples, 0.05%)</title><rect x="98.6720%" y="501" width="0.0486%" height="15" fill="rgb(224,132,51)" fg:x="38563" fg:w="19"/><text x="98.9220%" y="511.50"></text></g><g><title>clock_gettime (12 samples, 0.03%)</title><rect x="98.7206%" y="501" width="0.0307%" height="15" fill="rgb(240,63,7)" fg:x="38582" fg:w="12"/><text x="98.9706%" y="511.50"></text></g><g><title>core::hash::BuildHasher::hash_one (20 samples, 0.05%)</title><rect x="98.7513%" y="501" width="0.0512%" height="15" fill="rgb(249,182,41)" fg:x="38594" fg:w="20"/><text x="99.0013%" y="511.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (12 samples, 0.03%)</title><rect x="98.7718%" y="485" width="0.0307%" height="15" fill="rgb(243,47,26)" fg:x="38602" fg:w="12"/><text x="99.0218%" y="495.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (4 samples, 0.01%)</title><rect x="98.8025%" y="501" width="0.0102%" height="15" fill="rgb(233,48,2)" fg:x="38614" fg:w="4"/><text x="99.0525%" y="511.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::unwrap (7 samples, 0.02%)</title><rect x="98.8128%" y="501" width="0.0179%" height="15" fill="rgb(244,165,34)" fg:x="38618" fg:w="7"/><text x="99.0628%" y="511.50"></text></g><g><title>pthread_rwlock_rdlock (21 samples, 0.05%)</title><rect x="98.8383%" y="501" width="0.0537%" height="15" fill="rgb(207,89,7)" fg:x="38628" fg:w="21"/><text x="99.0883%" y="511.50"></text></g><g><title>pthread_rwlock_unlock (15 samples, 0.04%)</title><rect x="98.8921%" y="501" width="0.0384%" height="15" fill="rgb(244,117,36)" fg:x="38649" fg:w="15"/><text x="99.1421%" y="511.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (12 samples, 0.03%)</title><rect x="98.9305%" y="501" width="0.0307%" height="15" fill="rgb(226,144,34)" fg:x="38664" fg:w="12"/><text x="99.1805%" y="511.50"></text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (15 samples, 0.04%)</title><rect x="98.9612%" y="501" width="0.0384%" height="15" fill="rgb(213,23,19)" fg:x="38676" fg:w="15"/><text x="99.2112%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (7 samples, 0.02%)</title><rect x="99.0354%" y="485" width="0.0179%" height="15" fill="rgb(217,75,12)" fg:x="38705" fg:w="7"/><text x="99.2854%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv (24 samples, 0.06%)</title><rect x="98.9995%" y="501" width="0.0614%" height="15" fill="rgb(224,159,17)" fg:x="38691" fg:w="24"/><text x="99.2495%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (11 samples, 0.03%)</title><rect x="99.0609%" y="501" width="0.0281%" height="15" fill="rgb(217,118,1)" fg:x="38715" fg:w="11"/><text x="99.3109%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (12 samples, 0.03%)</title><rect x="99.0891%" y="501" width="0.0307%" height="15" fill="rgb(232,180,48)" fg:x="38726" fg:w="12"/><text x="99.3391%" y="511.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (9 samples, 0.02%)</title><rect x="99.1198%" y="501" width="0.0230%" height="15" fill="rgb(230,27,33)" fg:x="38738" fg:w="9"/><text x="99.3698%" y="511.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (19 samples, 0.05%)</title><rect x="99.1428%" y="501" width="0.0486%" height="15" fill="rgb(205,31,21)" fg:x="38747" fg:w="19"/><text x="99.3928%" y="511.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (4 samples, 0.01%)</title><rect x="99.1812%" y="485" width="0.0102%" height="15" fill="rgb(253,59,4)" fg:x="38762" fg:w="4"/><text x="99.4312%" y="495.50"></text></g><g><title>core::sync::atomic::atomic_load (4 samples, 0.01%)</title><rect x="99.1812%" y="469" width="0.0102%" height="15" fill="rgb(224,201,9)" fg:x="38762" fg:w="4"/><text x="99.4312%" y="479.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (6 samples, 0.02%)</title><rect x="99.1914%" y="501" width="0.0154%" height="15" fill="rgb(229,206,30)" fg:x="38766" fg:w="6"/><text x="99.4414%" y="511.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (6 samples, 0.02%)</title><rect x="99.2094%" y="501" width="0.0154%" height="15" fill="rgb(212,67,47)" fg:x="38773" fg:w="6"/><text x="99.4594%" y="511.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (15 samples, 0.04%)</title><rect x="99.2247%" y="501" width="0.0384%" height="15" fill="rgb(211,96,50)" fg:x="38779" fg:w="15"/><text x="99.4747%" y="511.50"></text></g><g><title>std::time::SystemTime::checked_add (5 samples, 0.01%)</title><rect x="99.2631%" y="501" width="0.0128%" height="15" fill="rgb(252,114,18)" fg:x="38794" fg:w="5"/><text x="99.5131%" y="511.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (21 samples, 0.05%)</title><rect x="99.2810%" y="501" width="0.0537%" height="15" fill="rgb(223,58,37)" fg:x="38801" fg:w="21"/><text x="99.5310%" y="511.50"></text></g><g><title>zssp::zeta::from_nonce (5 samples, 0.01%)</title><rect x="99.3347%" y="501" width="0.0128%" height="15" fill="rgb(237,70,4)" fg:x="38822" fg:w="5"/><text x="99.5847%" y="511.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (14 samples, 0.04%)</title><rect x="99.4038%" y="405" width="0.0358%" height="15" fill="rgb(244,85,46)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="415.50"></text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (14 samples, 0.04%)</title><rect x="99.4038%" y="389" width="0.0358%" height="15" fill="rgb(223,39,52)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="399.50"></text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (14 samples, 0.04%)</title><rect x="99.4038%" y="373" width="0.0358%" height="15" fill="rgb(218,200,14)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="383.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (14 samples, 0.04%)</title><rect x="99.4038%" y="357" width="0.0358%" height="15" fill="rgb(208,171,16)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="367.50"></text></g><g><title>alloc::alloc::Global::alloc_impl (14 samples, 0.04%)</title><rect x="99.4038%" y="341" width="0.0358%" height="15" fill="rgb(234,200,18)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="351.50"></text></g><g><title>alloc::alloc::alloc (14 samples, 0.04%)</title><rect x="99.4038%" y="325" width="0.0358%" height="15" fill="rgb(228,45,11)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="335.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (20 samples, 0.05%)</title><rect x="99.4038%" y="469" width="0.0512%" height="15" fill="rgb(237,182,11)" fg:x="38849" fg:w="20"/><text x="99.6538%" y="479.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (20 samples, 0.05%)</title><rect x="99.4038%" y="453" width="0.0512%" height="15" fill="rgb(241,175,49)" fg:x="38849" fg:w="20"/><text x="99.6538%" y="463.50"></text></g><g><title>alloc::slice::hack::to_vec (20 samples, 0.05%)</title><rect x="99.4038%" y="437" width="0.0512%" height="15" fill="rgb(247,38,35)" fg:x="38849" fg:w="20"/><text x="99.6538%" y="447.50"></text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (20 samples, 0.05%)</title><rect x="99.4038%" y="421" width="0.0512%" height="15" fill="rgb(228,39,49)" fg:x="38849" fg:w="20"/><text x="99.6538%" y="431.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (6 samples, 0.02%)</title><rect x="99.4396%" y="405" width="0.0154%" height="15" fill="rgb(226,101,26)" fg:x="38863" fg:w="6"/><text x="99.6896%" y="415.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (6 samples, 0.02%)</title><rect x="99.4396%" y="389" width="0.0154%" height="15" fill="rgb(206,141,19)" fg:x="38863" fg:w="6"/><text x="99.6896%" y="399.50"></text></g><g><title>zssp::zeta::send_payload (50 samples, 0.13%)</title><rect x="99.3501%" y="501" width="0.1279%" height="15" fill="rgb(211,200,13)" fg:x="38828" fg:w="50"/><text x="99.6001%" y="511.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (29 samples, 0.07%)</title><rect x="99.4038%" y="485" width="0.0742%" height="15" fill="rgb(241,121,6)" fg:x="38849" fg:w="29"/><text x="99.6538%" y="495.50"></text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (9 samples, 0.02%)</title><rect x="99.4550%" y="469" width="0.0230%" height="15" fill="rgb(234,221,29)" fg:x="38869" fg:w="9"/><text x="99.7050%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (7 samples, 0.02%)</title><rect x="99.5906%" y="485" width="0.0179%" height="15" fill="rgb(229,136,5)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="495.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="99.5906%" y="469" width="0.0179%" height="15" fill="rgb(238,36,11)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="479.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (7 samples, 0.02%)</title><rect x="99.5906%" y="453" width="0.0179%" height="15" fill="rgb(251,55,41)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (7 samples, 0.02%)</title><rect x="99.5906%" y="437" width="0.0179%" height="15" fill="rgb(242,34,40)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (7 samples, 0.02%)</title><rect x="99.5906%" y="421" width="0.0179%" height="15" fill="rgb(215,42,17)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (7 samples, 0.02%)</title><rect x="99.5906%" y="405" width="0.0179%" height="15" fill="rgb(207,44,46)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (7 samples, 0.02%)</title><rect x="99.5906%" y="389" width="0.0179%" height="15" fill="rgb(211,206,28)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="399.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (7 samples, 0.02%)</title><rect x="99.5906%" y="373" width="0.0179%" height="15" fill="rgb(237,167,16)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="383.50"></text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="99.5906%" y="357" width="0.0179%" height="15" fill="rgb(233,66,6)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="367.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (7 samples, 0.02%)</title><rect x="99.5906%" y="341" width="0.0179%" height="15" fill="rgb(246,123,29)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="351.50"></text></g><g><title>alloc::alloc::dealloc (7 samples, 0.02%)</title><rect x="99.5906%" y="325" width="0.0179%" height="15" fill="rgb(209,62,40)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="335.50"></text></g><g><title>cfree (5 samples, 0.01%)</title><rect x="99.5957%" y="309" width="0.0128%" height="15" fill="rgb(218,4,25)" fg:x="38924" fg:w="5"/><text x="99.8457%" y="319.50"></text></g><g><title>__lll_lock_wake_private (5 samples, 0.01%)</title><rect x="99.5957%" y="293" width="0.0128%" height="15" fill="rgb(253,91,49)" fg:x="38924" fg:w="5"/><text x="99.8457%" y="303.50"></text></g><g><title>__entry_text_start (5 samples, 0.01%)</title><rect x="99.5957%" y="277" width="0.0128%" height="15" fill="rgb(228,155,29)" fg:x="38924" fg:w="5"/><text x="99.8457%" y="287.50"></text></g><g><title>getrandom::imp::getrandom_inner (5 samples, 0.01%)</title><rect x="99.6085%" y="485" width="0.0128%" height="15" fill="rgb(243,57,37)" fg:x="38929" fg:w="5"/><text x="99.8585%" y="495.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (70 samples, 0.18%)</title><rect x="99.4780%" y="501" width="0.1791%" height="15" fill="rgb(244,167,17)" fg:x="38878" fg:w="70"/><text x="99.7280%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (13 samples, 0.03%)</title><rect x="99.6239%" y="485" width="0.0333%" height="15" fill="rgb(207,181,38)" fg:x="38935" fg:w="13"/><text x="99.8739%" y="495.50"></text></g><g><title>[unknown] (37,550 samples, 96.08%)</title><rect x="3.5873%" y="517" width="96.0800%" height="15" fill="rgb(211,8,23)" fg:x="1402" fg:w="37550"/><text x="3.8373%" y="527.50">[unknown]</text></g><g><title>zssp::zssp::parse_fragment_header (4 samples, 0.01%)</title><rect x="99.6571%" y="501" width="0.0102%" height="15" fill="rgb(235,11,44)" fg:x="38948" fg:w="4"/><text x="99.9071%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (31 samples, 0.08%)</title><rect x="99.6674%" y="501" width="0.0793%" height="15" fill="rgb(248,18,52)" fg:x="38952" fg:w="31"/><text x="99.9174%" y="511.50"></text></g><g><title>__bss_start (36 samples, 0.09%)</title><rect x="99.6674%" y="517" width="0.0921%" height="15" fill="rgb(208,4,7)" fg:x="38952" fg:w="36"/><text x="99.9174%" y="527.50"></text></g><g><title>[libcrypto.so.3] (5 samples, 0.01%)</title><rect x="99.7467%" y="501" width="0.0128%" height="15" fill="rgb(240,17,39)" fg:x="38983" fg:w="5"/><text x="99.9967%" y="511.50"></text></g><g><title>_raw_spin_unlock (4 samples, 0.01%)</title><rect x="99.7799%" y="293" width="0.0102%" height="15" fill="rgb(207,170,3)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="303.50"></text></g><g><title>preempt_schedule_thunk (4 samples, 0.01%)</title><rect x="99.7799%" y="277" width="0.0102%" height="15" fill="rgb(236,100,52)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="287.50"></text></g><g><title>preempt_schedule (4 samples, 0.01%)</title><rect x="99.7799%" y="261" width="0.0102%" height="15" fill="rgb(246,78,51)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="271.50"></text></g><g><title>__schedule (4 samples, 0.01%)</title><rect x="99.7799%" y="245" width="0.0102%" height="15" fill="rgb(211,17,15)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="255.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="99.7799%" y="229" width="0.0102%" height="15" fill="rgb(209,59,46)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="239.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="99.7799%" y="213" width="0.0102%" height="15" fill="rgb(210,92,25)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="223.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="99.7799%" y="197" width="0.0102%" height="15" fill="rgb(238,174,52)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="207.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (9 samples, 0.02%)</title><rect x="99.7697%" y="517" width="0.0230%" height="15" fill="rgb(230,73,7)" fg:x="38992" fg:w="9"/><text x="100.0197%" y="527.50"></text></g><g><title>do_syscall_64 (7 samples, 0.02%)</title><rect x="99.7748%" y="501" width="0.0179%" height="15" fill="rgb(243,124,40)" fg:x="38994" fg:w="7"/><text x="100.0248%" y="511.50"></text></g><g><title>__x64_sys_exit_group (6 samples, 0.02%)</title><rect x="99.7774%" y="485" width="0.0154%" height="15" fill="rgb(244,170,11)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="495.50"></text></g><g><title>do_group_exit (6 samples, 0.02%)</title><rect x="99.7774%" y="469" width="0.0154%" height="15" fill="rgb(207,114,54)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="479.50"></text></g><g><title>do_exit (6 samples, 0.02%)</title><rect x="99.7774%" y="453" width="0.0154%" height="15" fill="rgb(205,42,20)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="463.50"></text></g><g><title>exit_mm (6 samples, 0.02%)</title><rect x="99.7774%" y="437" width="0.0154%" height="15" fill="rgb(230,30,28)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="447.50"></text></g><g><title>mmput (6 samples, 0.02%)</title><rect x="99.7774%" y="421" width="0.0154%" height="15" fill="rgb(205,73,54)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="431.50"></text></g><g><title>__mmput (6 samples, 0.02%)</title><rect x="99.7774%" y="405" width="0.0154%" height="15" fill="rgb(254,227,23)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="415.50"></text></g><g><title>exit_mmap (6 samples, 0.02%)</title><rect x="99.7774%" y="389" width="0.0154%" height="15" fill="rgb(228,202,34)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="399.50"></text></g><g><title>unmap_vmas (5 samples, 0.01%)</title><rect x="99.7799%" y="373" width="0.0128%" height="15" fill="rgb(222,225,37)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="383.50"></text></g><g><title>unmap_single_vma (5 samples, 0.01%)</title><rect x="99.7799%" y="357" width="0.0128%" height="15" fill="rgb(221,14,54)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="367.50"></text></g><g><title>unmap_page_range (5 samples, 0.01%)</title><rect x="99.7799%" y="341" width="0.0128%" height="15" fill="rgb(254,102,2)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="351.50"></text></g><g><title>zap_pmd_range.isra.0 (5 samples, 0.01%)</title><rect x="99.7799%" y="325" width="0.0128%" height="15" fill="rgb(232,104,17)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="335.50"></text></g><g><title>zap_pte_range (5 samples, 0.01%)</title><rect x="99.7799%" y="309" width="0.0128%" height="15" fill="rgb(250,220,14)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="319.50"></text></g><g><title>entry_SYSCALL_64_safe_stack (15 samples, 0.04%)</title><rect x="99.7927%" y="517" width="0.0384%" height="15" fill="rgb(241,158,9)" fg:x="39001" fg:w="15"/><text x="100.0427%" y="527.50"></text></g><g><title>ret_from_fork (10 samples, 0.03%)</title><rect x="99.8311%" y="517" width="0.0256%" height="15" fill="rgb(246,9,43)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="527.50"></text></g><g><title>schedule_tail (10 samples, 0.03%)</title><rect x="99.8311%" y="501" width="0.0256%" height="15" fill="rgb(206,73,33)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="511.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="99.8311%" y="485" width="0.0256%" height="15" fill="rgb(222,79,8)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="495.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="99.8311%" y="469" width="0.0256%" height="15" fill="rgb(234,8,54)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="479.50"></text></g><g><title>perf_ctx_enable (10 samples, 0.03%)</title><rect x="99.8311%" y="453" width="0.0256%" height="15" fill="rgb(209,134,38)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="463.50"></text></g><g><title>syscall_return_via_sysret (9 samples, 0.02%)</title><rect x="99.8593%" y="517" width="0.0230%" height="15" fill="rgb(230,127,29)" fg:x="39027" fg:w="9"/><text x="100.1093%" y="527.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9693%" y="501" width="0.0128%" height="15" fill="rgb(242,44,41)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="511.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (5 samples, 0.01%)</title><rect x="99.9693%" y="485" width="0.0128%" height="15" fill="rgb(222,56,43)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="495.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (5 samples, 0.01%)</title><rect x="99.9693%" y="469" width="0.0128%" height="15" fill="rgb(238,39,47)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="479.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (5 samples, 0.01%)</title><rect x="99.9693%" y="453" width="0.0128%" height="15" fill="rgb(226,79,43)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (5 samples, 0.01%)</title><rect x="99.9693%" y="437" width="0.0128%" height="15" fill="rgb(242,105,53)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (5 samples, 0.01%)</title><rect x="99.9693%" y="421" width="0.0128%" height="15" fill="rgb(251,132,46)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9693%" y="405" width="0.0128%" height="15" fill="rgb(231,77,14)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9693%" y="389" width="0.0128%" height="15" fill="rgb(240,135,9)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="399.50"></text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (5 samples, 0.01%)</title><rect x="99.9693%" y="373" width="0.0128%" height="15" fill="rgb(248,109,14)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="383.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (5 samples, 0.01%)</title><rect x="99.9693%" y="357" width="0.0128%" height="15" fill="rgb(227,146,52)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="367.50"></text></g><g><title>alloc::alloc::dealloc (5 samples, 0.01%)</title><rect x="99.9693%" y="341" width="0.0128%" height="15" fill="rgb(232,54,3)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="351.50"></text></g><g><title>benchmark (39,077 samples, 99.99%)</title><rect x="0.0000%" y="533" width="99.9872%" height="15" fill="rgb(229,201,43)" fg:x="0" fg:w="39077"/><text x="0.2500%" y="543.50">benchmark</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (41 samples, 0.10%)</title><rect x="99.8823%" y="517" width="0.1049%" height="15" fill="rgb(252,161,33)" fg:x="39036" fg:w="41"/><text x="100.1323%" y="527.50"></text></g><g><title>perf_event_exec (4 samples, 0.01%)</title><rect x="99.9872%" y="357" width="0.0102%" height="15" fill="rgb(226,146,40)" fg:x="39077" fg:w="4"/><text x="100.2372%" y="367.50"></text></g><g><title>perf_event_enable_on_exec (4 samples, 0.01%)</title><rect x="99.9872%" y="341" width="0.0102%" height="15" fill="rgb(219,47,25)" fg:x="39077" fg:w="4"/><text x="100.2372%" y="351.50"></text></g><g><title>ctx_resched (4 samples, 0.01%)</title><rect x="99.9872%" y="325" width="0.0102%" height="15" fill="rgb(250,135,13)" fg:x="39077" fg:w="4"/><text x="100.2372%" y="335.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="99.9872%" y="309" width="0.0102%" height="15" fill="rgb(219,229,18)" fg:x="39077" fg:w="4"/><text x="100.2372%" y="319.50"></text></g><g><title>all (39,082 samples, 100%)</title><rect x="0.0000%" y="549" width="100.0000%" height="15" fill="rgb(217,152,27)" fg:x="0" fg:w="39082"/><text x="0.2500%" y="559.50"></text></g><g><title>perf-exec (5 samples, 0.01%)</title><rect x="99.9872%" y="533" width="0.0128%" height="15" fill="rgb(225,71,47)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="543.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (5 samples, 0.01%)</title><rect x="99.9872%" y="517" width="0.0128%" height="15" fill="rgb(220,139,14)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="527.50"></text></g><g><title>do_syscall_64 (5 samples, 0.01%)</title><rect x="99.9872%" y="501" width="0.0128%" height="15" fill="rgb(247,54,32)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="511.50"></text></g><g><title>__x64_sys_execve (5 samples, 0.01%)</title><rect x="99.9872%" y="485" width="0.0128%" height="15" fill="rgb(252,131,39)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="495.50"></text></g><g><title>do_execveat_common.isra.0 (5 samples, 0.01%)</title><rect x="99.9872%" y="469" width="0.0128%" height="15" fill="rgb(210,108,39)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="479.50"></text></g><g><title>bprm_execve (5 samples, 0.01%)</title><rect x="99.9872%" y="453" width="0.0128%" height="15" fill="rgb(205,23,29)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="463.50"></text></g><g><title>bprm_execve.part.0 (5 samples, 0.01%)</title><rect x="99.9872%" y="437" width="0.0128%" height="15" fill="rgb(246,139,46)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="447.50"></text></g><g><title>exec_binprm (5 samples, 0.01%)</title><rect x="99.9872%" y="421" width="0.0128%" height="15" fill="rgb(250,81,26)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="431.50"></text></g><g><title>search_binary_handler (5 samples, 0.01%)</title><rect x="99.9872%" y="405" width="0.0128%" height="15" fill="rgb(214,104,7)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="415.50"></text></g><g><title>load_elf_binary (5 samples, 0.01%)</title><rect x="99.9872%" y="389" width="0.0128%" height="15" fill="rgb(233,189,8)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="399.50"></text></g><g><title>begin_new_exec (5 samples, 0.01%)</title><rect x="99.9872%" y="373" width="0.0128%" height="15" fill="rgb(228,141,17)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="383.50"></text></g></svg></svg>
\ No newline at end of file
diff --git a/src/zeta.rs b/src/zeta.rs
index f6d3cb7..cd4ce9a 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -1676,16 +1676,11 @@ pub(crate) fn send_payload<Crypto: CryptoLayer>(
 
         mtu_sized_buffer[..HEADER_SIZE].copy_from_slice(&header);
         mtu_sized_buffer[FRAGMENT_NO_IDX] = fragment_no as u8;
-        cipher.encrypt(
-            &payload[i..j],
-            &mut mtu_sized_buffer[HEADER_SIZE..HEADER_SIZE + fragment_len],
-        );
+        let fragment_start = &mut mtu_sized_buffer[HEADER_SIZE..HEADER_SIZE + fragment_len];
+        cipher.encrypt(&payload[i..j], fragment_start);
 
-        state.hk_send.encrypt_in_place(
-            (&mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END])
-                .try_into()
-                .unwrap(),
-        );
+        let header_auth = &mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END];
+        state.hk_send.encrypt_in_place(header_auth.try_into().unwrap());
 
         if !send(&mut mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
             return Ok(());
@@ -1699,17 +1694,12 @@ pub(crate) fn send_payload<Crypto: CryptoLayer>(
 
     mtu_sized_buffer[..HEADER_SIZE].copy_from_slice(&header);
     mtu_sized_buffer[FRAGMENT_NO_IDX] = fragment_no as u8;
-    cipher.encrypt(
-        &payload[i..],
-        &mut mtu_sized_buffer[HEADER_SIZE..HEADER_SIZE + payload_rem],
-    );
+    let fragment_start = &mut mtu_sized_buffer[HEADER_SIZE..HEADER_SIZE + payload_rem];
+    cipher.encrypt(&payload[i..], fragment_start);
     mtu_sized_buffer[HEADER_SIZE + payload_rem..HEADER_SIZE + fragment_len].copy_from_slice(&cipher.finish());
 
-    state.hk_send.encrypt_in_place(
-        (&mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END])
-            .try_into()
-            .unwrap(),
-    );
+    let header_auth = &mut mtu_sized_buffer[HEADER_AUTH_START..HEADER_AUTH_END];
+    state.hk_send.encrypt_in_place(header_auth.try_into().unwrap());
 
     if !send(&mut mtu_sized_buffer[..HEADER_SIZE + fragment_len]) {
         return Ok(());
diff --git a/src/zssp.rs b/src/zssp.rs
index 2996c0c..27b24a6 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -549,7 +549,8 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
                             challenge_packet.extend(challenge);
                             let nonce = to_nonce(PACKET_TYPE_CHALLENGE, ctx.rng.lock().unwrap().next_u64());
                             challenge_packet[FRAGMENT_COUNT_IDX] = 1;
-                            challenge_packet[PACKET_NONCE_START..HEADER_SIZE].copy_from_slice(&nonce[..PACKET_NONCE_SIZE]);
+                            challenge_packet[PACKET_NONCE_START..HEADER_SIZE]
+                                .copy_from_slice(&nonce[..PACKET_NONCE_SIZE]);
                             set_header(&mut challenge_packet, 0, &nonce);
 
                             send_unassociated_reply(&mut challenge_packet);

From ef0cde79ce560c96d54e1bba5fe506255c8afe8a Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 17:03:00 -0400
Subject: [PATCH 39/50] improved performance

---
 .gitignore                 |  3 +-
 flamegraph.svg             |  2 +-
 src/crypto_impl/openssl.rs | 62 +++++++++++++++++++++++---------------
 3 files changed, 41 insertions(+), 26 deletions(-)

diff --git a/.gitignore b/.gitignore
index 790f4b6..68e7d6c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 /target
-./perf*
+perf*.data
+perf*.old
diff --git a/flamegraph.svg b/flamegraph.svg
index 8075ab4..a00c032 100644
--- a/flamegraph.svg
+++ b/flamegraph.svg
@@ -488,4 +488,4 @@ function search(term) {
 function format_percent(n) {
     return n.toFixed(4) + "%";
 }
-]]></script><rect x="0" y="0" width="100%" height="598" fill="url(#background)"/><text id="title" fill="rgb(0,0,0)" x="50.0000%" y="24.00">Flame Graph</text><text id="details" fill="rgb(0,0,0)" x="10" y="581.00"> </text><text id="unzoom" class="hide" fill="rgb(0,0,0)" x="10" y="24.00">Reset Zoom</text><text id="search" fill="rgb(0,0,0)" x="1190" y="24.00">Search</text><text id="matched" fill="rgb(0,0,0)" x="1190" y="581.00"> </text><svg id="frames" x="10" width="1180" total_samples="39082"><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (13 samples, 0.03%)</title><rect x="0.0179%" y="501" width="0.0333%" height="15" fill="rgb(227,0,7)" fg:x="7" fg:w="13"/><text x="0.2679%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (5 samples, 0.01%)</title><rect x="0.0384%" y="485" width="0.0128%" height="15" fill="rgb(217,0,24)" fg:x="15" fg:w="5"/><text x="0.2884%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (35 samples, 0.09%)</title><rect x="0.0512%" y="501" width="0.0896%" height="15" fill="rgb(221,193,54)" fg:x="20" fg:w="35"/><text x="0.3012%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (5 samples, 0.01%)</title><rect x="0.1279%" y="485" width="0.0128%" height="15" fill="rgb(248,212,6)" fg:x="50" fg:w="5"/><text x="0.3779%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (71 samples, 0.18%)</title><rect x="0.1407%" y="501" width="0.1817%" height="15" fill="rgb(208,68,35)" fg:x="55" fg:w="71"/><text x="0.3907%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (8 samples, 0.02%)</title><rect x="0.3301%" y="501" width="0.0205%" height="15" fill="rgb(232,128,0)" fg:x="129" fg:w="8"/><text x="0.5801%" y="511.50"></text></g><g><title>CRYPTO_THREAD_read_lock (7 samples, 0.02%)</title><rect x="0.3505%" y="501" width="0.0179%" height="15" fill="rgb(207,160,47)" fg:x="137" fg:w="7"/><text x="0.6005%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt (8 samples, 0.02%)</title><rect x="0.3736%" y="501" width="0.0205%" height="15" fill="rgb(228,23,34)" fg:x="146" fg:w="8"/><text x="0.6236%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (21 samples, 0.05%)</title><rect x="0.3940%" y="501" width="0.0537%" height="15" fill="rgb(218,30,26)" fg:x="154" fg:w="21"/><text x="0.6440%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt (10 samples, 0.03%)</title><rect x="0.4478%" y="501" width="0.0256%" height="15" fill="rgb(220,122,19)" fg:x="175" fg:w="10"/><text x="0.6978%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (16 samples, 0.04%)</title><rect x="0.4734%" y="501" width="0.0409%" height="15" fill="rgb(250,228,42)" fg:x="185" fg:w="16"/><text x="0.7234%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (4 samples, 0.01%)</title><rect x="0.5143%" y="501" width="0.0102%" height="15" fill="rgb(240,193,28)" fg:x="201" fg:w="4"/><text x="0.7643%" y="511.50"></text></g><g><title>CRYPTO_gcm128_init (9 samples, 0.02%)</title><rect x="0.5245%" y="501" width="0.0230%" height="15" fill="rgb(216,20,37)" fg:x="205" fg:w="9"/><text x="0.7745%" y="511.50"></text></g><g><title>CRYPTO_gcm128_tag (5 samples, 0.01%)</title><rect x="0.5501%" y="501" width="0.0128%" height="15" fill="rgb(206,188,39)" fg:x="215" fg:w="5"/><text x="0.8001%" y="511.50"></text></g><g><title>CRYPTO_zalloc (25 samples, 0.06%)</title><rect x="0.5629%" y="501" width="0.0640%" height="15" fill="rgb(217,207,13)" fg:x="220" fg:w="25"/><text x="0.8129%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (5 samples, 0.01%)</title><rect x="0.6269%" y="501" width="0.0128%" height="15" fill="rgb(231,73,38)" fg:x="245" fg:w="5"/><text x="0.8769%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_reset (7 samples, 0.02%)</title><rect x="0.6474%" y="501" width="0.0179%" height="15" fill="rgb(225,20,46)" fg:x="253" fg:w="7"/><text x="0.8974%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (12 samples, 0.03%)</title><rect x="0.6653%" y="501" width="0.0307%" height="15" fill="rgb(210,31,41)" fg:x="260" fg:w="12"/><text x="0.9153%" y="511.50"></text></g><g><title>EVP_CIPHER_fetch (6 samples, 0.02%)</title><rect x="0.6960%" y="501" width="0.0154%" height="15" fill="rgb(221,200,47)" fg:x="272" fg:w="6"/><text x="0.9460%" y="511.50"></text></g><g><title>EVP_CIPHER_free (17 samples, 0.04%)</title><rect x="0.7113%" y="501" width="0.0435%" height="15" fill="rgb(226,26,5)" fg:x="278" fg:w="17"/><text x="0.9613%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (4 samples, 0.01%)</title><rect x="0.7702%" y="501" width="0.0102%" height="15" fill="rgb(249,33,26)" fg:x="301" fg:w="4"/><text x="1.0202%" y="511.50"></text></g><g><title>EVP_EncryptFinal_ex (6 samples, 0.02%)</title><rect x="0.7804%" y="501" width="0.0154%" height="15" fill="rgb(235,183,28)" fg:x="305" fg:w="6"/><text x="1.0304%" y="511.50"></text></g><g><title>OPENSSL_LH_retrieve (10 samples, 0.03%)</title><rect x="0.8137%" y="501" width="0.0256%" height="15" fill="rgb(221,5,38)" fg:x="318" fg:w="10"/><text x="1.0637%" y="511.50"></text></g><g><title>OPENSSL_strnlen (5 samples, 0.01%)</title><rect x="0.8469%" y="501" width="0.0128%" height="15" fill="rgb(247,18,42)" fg:x="331" fg:w="5"/><text x="1.0969%" y="511.50"></text></g><g><title>OSSL_PARAM_locate (121 samples, 0.31%)</title><rect x="0.8623%" y="501" width="0.3096%" height="15" fill="rgb(241,131,45)" fg:x="337" fg:w="121"/><text x="1.1123%" y="511.50"></text></g><g><title>OSSL_PARAM_set_uint64 (4 samples, 0.01%)</title><rect x="1.1745%" y="501" width="0.0102%" height="15" fill="rgb(249,31,29)" fg:x="459" fg:w="4"/><text x="1.4245%" y="511.50"></text></g><g><title>[libc.so.6] (60 samples, 0.15%)</title><rect x="1.1898%" y="501" width="0.1535%" height="15" fill="rgb(225,111,53)" fg:x="465" fg:w="60"/><text x="1.4398%" y="511.50"></text></g><g><title>[libcrypto.so.3] (289 samples, 0.74%)</title><rect x="1.3433%" y="501" width="0.7395%" height="15" fill="rgb(238,160,17)" fg:x="525" fg:w="289"/><text x="1.5933%" y="511.50"></text></g><g><title>cfree (13 samples, 0.03%)</title><rect x="2.0905%" y="501" width="0.0333%" height="15" fill="rgb(214,148,48)" fg:x="817" fg:w="13"/><text x="2.3405%" y="511.50"></text></g><g><title>malloc (31 samples, 0.08%)</title><rect x="2.1340%" y="501" width="0.0793%" height="15" fill="rgb(232,36,49)" fg:x="834" fg:w="31"/><text x="2.3840%" y="511.50"></text></g><g><title>pthread_rwlock_rdlock (5 samples, 0.01%)</title><rect x="2.2159%" y="501" width="0.0128%" height="15" fill="rgb(209,103,24)" fg:x="866" fg:w="5"/><text x="2.4659%" y="511.50"></text></g><g><title>pthread_rwlock_unlock (7 samples, 0.02%)</title><rect x="2.2286%" y="501" width="0.0179%" height="15" fill="rgb(229,88,8)" fg:x="871" fg:w="7"/><text x="2.4786%" y="511.50"></text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (9 samples, 0.02%)</title><rect x="2.2542%" y="501" width="0.0230%" height="15" fill="rgb(213,181,19)" fg:x="881" fg:w="9"/><text x="2.5042%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (11 samples, 0.03%)</title><rect x="2.3233%" y="485" width="0.0281%" height="15" fill="rgb(254,191,54)" fg:x="908" fg:w="11"/><text x="2.5733%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (11 samples, 0.03%)</title><rect x="2.3515%" y="485" width="0.0281%" height="15" fill="rgb(241,83,37)" fg:x="919" fg:w="11"/><text x="2.6015%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (45 samples, 0.12%)</title><rect x="2.2824%" y="501" width="0.1151%" height="15" fill="rgb(233,36,39)" fg:x="892" fg:w="45"/><text x="2.5324%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (7 samples, 0.02%)</title><rect x="2.3796%" y="485" width="0.0179%" height="15" fill="rgb(226,3,54)" fg:x="930" fg:w="7"/><text x="2.6296%" y="495.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (5 samples, 0.01%)</title><rect x="2.4333%" y="485" width="0.0128%" height="15" fill="rgb(245,192,40)" fg:x="951" fg:w="5"/><text x="2.6833%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::try_recv (19 samples, 0.05%)</title><rect x="2.4026%" y="501" width="0.0486%" height="15" fill="rgb(238,167,29)" fg:x="939" fg:w="19"/><text x="2.6526%" y="511.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (11 samples, 0.03%)</title><rect x="2.4513%" y="501" width="0.0281%" height="15" fill="rgb(232,182,51)" fg:x="958" fg:w="11"/><text x="2.7013%" y="511.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (10 samples, 0.03%)</title><rect x="2.4794%" y="485" width="0.0256%" height="15" fill="rgb(231,60,39)" fg:x="969" fg:w="10"/><text x="2.7294%" y="495.50"></text></g><g><title>core::sync::atomic::atomic_load (10 samples, 0.03%)</title><rect x="2.4794%" y="469" width="0.0256%" height="15" fill="rgb(208,69,12)" fg:x="969" fg:w="10"/><text x="2.7294%" y="479.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (11 samples, 0.03%)</title><rect x="2.4794%" y="501" width="0.0281%" height="15" fill="rgb(235,93,37)" fg:x="969" fg:w="11"/><text x="2.7294%" y="511.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (7 samples, 0.02%)</title><rect x="2.5075%" y="501" width="0.0179%" height="15" fill="rgb(213,116,39)" fg:x="980" fg:w="7"/><text x="2.7575%" y="511.50"></text></g><g><title>std::time::Instant::elapsed (7 samples, 0.02%)</title><rect x="2.5255%" y="501" width="0.0179%" height="15" fill="rgb(222,207,29)" fg:x="987" fg:w="7"/><text x="2.7755%" y="511.50"></text></g><g><title>syscall (10 samples, 0.03%)</title><rect x="2.5434%" y="501" width="0.0256%" height="15" fill="rgb(206,96,30)" fg:x="994" fg:w="10"/><text x="2.7934%" y="511.50"></text></g><g><title>__entry_text_start (6 samples, 0.02%)</title><rect x="2.5536%" y="485" width="0.0154%" height="15" fill="rgb(218,138,4)" fg:x="998" fg:w="6"/><text x="2.8036%" y="495.50"></text></g><g><title>[anon] (1,024 samples, 2.62%)</title><rect x="0.0154%" y="517" width="2.6201%" height="15" fill="rgb(250,191,14)" fg:x="6" fg:w="1024"/><text x="0.2654%" y="527.50">[a..</text></g><g><title>zssp::zeta::receive_payload_in_place (25 samples, 0.06%)</title><rect x="2.5715%" y="501" width="0.0640%" height="15" fill="rgb(239,60,40)" fg:x="1005" fg:w="25"/><text x="2.8215%" y="511.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (7 samples, 0.02%)</title><rect x="2.6176%" y="485" width="0.0179%" height="15" fill="rgb(206,27,48)" fg:x="1023" fg:w="7"/><text x="2.8676%" y="495.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (7 samples, 0.02%)</title><rect x="2.6176%" y="469" width="0.0179%" height="15" fill="rgb(225,35,8)" fg:x="1023" fg:w="7"/><text x="2.8676%" y="479.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (7 samples, 0.02%)</title><rect x="2.6176%" y="453" width="0.0179%" height="15" fill="rgb(250,213,24)" fg:x="1023" fg:w="7"/><text x="2.8676%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (7 samples, 0.02%)</title><rect x="2.6176%" y="437" width="0.0179%" height="15" fill="rgb(247,123,22)" fg:x="1023" fg:w="7"/><text x="2.8676%" y="447.50"></text></g><g><title>&lt;std::sync::mpmc::zero::ZeroToken as core::default::Default&gt;::default (4 samples, 0.01%)</title><rect x="2.6355%" y="501" width="0.0102%" height="15" fill="rgb(231,138,38)" fg:x="1030" fg:w="4"/><text x="2.8855%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (4 samples, 0.01%)</title><rect x="2.6457%" y="501" width="0.0102%" height="15" fill="rgb(231,145,46)" fg:x="1034" fg:w="4"/><text x="2.8957%" y="511.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="2.6560%" y="501" width="0.0128%" height="15" fill="rgb(251,118,11)" fg:x="1038" fg:w="5"/><text x="2.9060%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (8 samples, 0.02%)</title><rect x="2.6764%" y="501" width="0.0205%" height="15" fill="rgb(217,147,25)" fg:x="1046" fg:w="8"/><text x="2.9264%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (9 samples, 0.02%)</title><rect x="2.6969%" y="501" width="0.0230%" height="15" fill="rgb(247,81,37)" fg:x="1054" fg:w="9"/><text x="2.9469%" y="511.50"></text></g><g><title>[benchmark] (54 samples, 0.14%)</title><rect x="2.6355%" y="517" width="0.1382%" height="15" fill="rgb(209,12,38)" fg:x="1030" fg:w="54"/><text x="2.8855%" y="527.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (17 samples, 0.04%)</title><rect x="2.7302%" y="501" width="0.0435%" height="15" fill="rgb(227,1,9)" fg:x="1067" fg:w="17"/><text x="2.9802%" y="511.50"></text></g><g><title>CRYPTO_THREAD_read_lock (17 samples, 0.04%)</title><rect x="2.8120%" y="501" width="0.0435%" height="15" fill="rgb(248,47,43)" fg:x="1099" fg:w="17"/><text x="3.0620%" y="511.50"></text></g><g><title>CRYPTO_THREAD_run_once (4 samples, 0.01%)</title><rect x="2.8555%" y="501" width="0.0102%" height="15" fill="rgb(221,10,30)" fg:x="1116" fg:w="4"/><text x="3.1055%" y="511.50"></text></g><g><title>CRYPTO_THREAD_unlock (19 samples, 0.05%)</title><rect x="2.8658%" y="501" width="0.0486%" height="15" fill="rgb(210,229,1)" fg:x="1120" fg:w="19"/><text x="3.1158%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (14 samples, 0.04%)</title><rect x="2.9144%" y="501" width="0.0358%" height="15" fill="rgb(222,148,37)" fg:x="1139" fg:w="14"/><text x="3.1644%" y="511.50"></text></g><g><title>CRYPTO_gcm128_setiv (7 samples, 0.02%)</title><rect x="2.9502%" y="501" width="0.0179%" height="15" fill="rgb(234,67,33)" fg:x="1153" fg:w="7"/><text x="3.2002%" y="511.50"></text></g><g><title>CRYPTO_get_ex_data (10 samples, 0.03%)</title><rect x="2.9681%" y="501" width="0.0256%" height="15" fill="rgb(247,98,35)" fg:x="1160" fg:w="10"/><text x="3.2181%" y="511.50"></text></g><g><title>OPENSSL_sk_value (4 samples, 0.01%)</title><rect x="3.0065%" y="501" width="0.0102%" height="15" fill="rgb(247,138,52)" fg:x="1175" fg:w="4"/><text x="3.2565%" y="511.50"></text></g><g><title>OSSL_PARAM_construct_size_t (5 samples, 0.01%)</title><rect x="3.0193%" y="501" width="0.0128%" height="15" fill="rgb(213,79,30)" fg:x="1180" fg:w="5"/><text x="3.2693%" y="511.50"></text></g><g><title>[libc.so.6] (17 samples, 0.04%)</title><rect x="3.0346%" y="501" width="0.0435%" height="15" fill="rgb(246,177,23)" fg:x="1186" fg:w="17"/><text x="3.2846%" y="511.50"></text></g><g><title>[libcrypto.so.3] (145 samples, 0.37%)</title><rect x="3.0781%" y="501" width="0.3710%" height="15" fill="rgb(230,62,27)" fg:x="1203" fg:w="145"/><text x="3.3281%" y="511.50"></text></g><g><title>pthread_getspecific (7 samples, 0.02%)</title><rect x="3.4568%" y="501" width="0.0179%" height="15" fill="rgb(216,154,8)" fg:x="1351" fg:w="7"/><text x="3.7068%" y="511.50"></text></g><g><title>pthread_rwlock_rdlock (22 samples, 0.06%)</title><rect x="3.4747%" y="501" width="0.0563%" height="15" fill="rgb(244,35,45)" fg:x="1358" fg:w="22"/><text x="3.7247%" y="511.50"></text></g><g><title>[libcrypto.so.3] (316 samples, 0.81%)</title><rect x="2.7788%" y="517" width="0.8086%" height="15" fill="rgb(251,115,12)" fg:x="1086" fg:w="316"/><text x="3.0288%" y="527.50"></text></g><g><title>pthread_rwlock_unlock (22 samples, 0.06%)</title><rect x="3.5310%" y="501" width="0.0563%" height="15" fill="rgb(240,54,50)" fg:x="1380" fg:w="22"/><text x="3.7810%" y="511.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (14 samples, 0.04%)</title><rect x="3.5873%" y="501" width="0.0358%" height="15" fill="rgb(233,84,52)" fg:x="1402" fg:w="14"/><text x="3.8373%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (14 samples, 0.04%)</title><rect x="3.6334%" y="501" width="0.0358%" height="15" fill="rgb(207,117,47)" fg:x="1420" fg:w="14"/><text x="3.8834%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (4 samples, 0.01%)</title><rect x="3.6692%" y="501" width="0.0102%" height="15" fill="rgb(249,43,39)" fg:x="1434" fg:w="4"/><text x="3.9192%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (80 samples, 0.20%)</title><rect x="3.6794%" y="501" width="0.2047%" height="15" fill="rgb(209,38,44)" fg:x="1438" fg:w="80"/><text x="3.9294%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (10 samples, 0.03%)</title><rect x="3.8586%" y="485" width="0.0256%" height="15" fill="rgb(236,212,23)" fg:x="1508" fg:w="10"/><text x="4.1086%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (5 samples, 0.01%)</title><rect x="3.8841%" y="501" width="0.0128%" height="15" fill="rgb(242,79,21)" fg:x="1518" fg:w="5"/><text x="4.1341%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (8 samples, 0.02%)</title><rect x="3.8969%" y="501" width="0.0205%" height="15" fill="rgb(211,96,35)" fg:x="1523" fg:w="8"/><text x="4.1469%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (8 samples, 0.02%)</title><rect x="3.8969%" y="485" width="0.0205%" height="15" fill="rgb(253,215,40)" fg:x="1523" fg:w="8"/><text x="4.1469%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (7 samples, 0.02%)</title><rect x="3.9174%" y="501" width="0.0179%" height="15" fill="rgb(211,81,21)" fg:x="1531" fg:w="7"/><text x="4.1674%" y="511.50"></text></g><g><title>CRYPTO_THREAD_read_lock (6 samples, 0.02%)</title><rect x="3.9353%" y="501" width="0.0154%" height="15" fill="rgb(208,190,38)" fg:x="1538" fg:w="6"/><text x="4.1853%" y="511.50"></text></g><g><title>CRYPTO_THREAD_unlock (11 samples, 0.03%)</title><rect x="3.9532%" y="501" width="0.0281%" height="15" fill="rgb(235,213,38)" fg:x="1545" fg:w="11"/><text x="4.2032%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt (10 samples, 0.03%)</title><rect x="3.9890%" y="501" width="0.0256%" height="15" fill="rgb(237,122,38)" fg:x="1559" fg:w="10"/><text x="4.2390%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (22 samples, 0.06%)</title><rect x="4.0146%" y="501" width="0.0563%" height="15" fill="rgb(244,218,35)" fg:x="1569" fg:w="22"/><text x="4.2646%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt (15 samples, 0.04%)</title><rect x="4.0709%" y="501" width="0.0384%" height="15" fill="rgb(240,68,47)" fg:x="1591" fg:w="15"/><text x="4.3209%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (28 samples, 0.07%)</title><rect x="4.1093%" y="501" width="0.0716%" height="15" fill="rgb(210,16,53)" fg:x="1606" fg:w="28"/><text x="4.3593%" y="511.50"></text></g><g><title>CRYPTO_strndup (5 samples, 0.01%)</title><rect x="4.1912%" y="501" width="0.0128%" height="15" fill="rgb(235,124,12)" fg:x="1638" fg:w="5"/><text x="4.4412%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (10 samples, 0.03%)</title><rect x="4.2040%" y="501" width="0.0256%" height="15" fill="rgb(224,169,11)" fg:x="1643" fg:w="10"/><text x="4.4540%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (4 samples, 0.01%)</title><rect x="4.2347%" y="501" width="0.0102%" height="15" fill="rgb(250,166,2)" fg:x="1655" fg:w="4"/><text x="4.4847%" y="511.50"></text></g><g><title>EVP_CIPHER_get_block_size (9 samples, 0.02%)</title><rect x="4.2603%" y="501" width="0.0230%" height="15" fill="rgb(242,216,29)" fg:x="1665" fg:w="9"/><text x="4.5103%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (54 samples, 0.14%)</title><rect x="4.2935%" y="501" width="0.1382%" height="15" fill="rgb(230,116,27)" fg:x="1678" fg:w="54"/><text x="4.5435%" y="511.50"></text></g><g><title>EVP_EncryptUpdate (45 samples, 0.12%)</title><rect x="4.4368%" y="501" width="0.1151%" height="15" fill="rgb(228,99,48)" fg:x="1734" fg:w="45"/><text x="4.6868%" y="511.50"></text></g><g><title>OPENSSL_LH_retrieve (8 samples, 0.02%)</title><rect x="4.5520%" y="501" width="0.0205%" height="15" fill="rgb(253,11,6)" fg:x="1779" fg:w="8"/><text x="4.8020%" y="511.50"></text></g><g><title>OPENSSL_init_crypto (4 samples, 0.01%)</title><rect x="4.5724%" y="501" width="0.0102%" height="15" fill="rgb(247,143,39)" fg:x="1787" fg:w="4"/><text x="4.8224%" y="511.50"></text></g><g><title>OSSL_PARAM_locate (18 samples, 0.05%)</title><rect x="4.5878%" y="501" width="0.0461%" height="15" fill="rgb(236,97,10)" fg:x="1793" fg:w="18"/><text x="4.8378%" y="511.50"></text></g><g><title>[[vdso]] (8 samples, 0.02%)</title><rect x="4.6390%" y="501" width="0.0205%" height="15" fill="rgb(233,208,19)" fg:x="1813" fg:w="8"/><text x="4.8890%" y="511.50"></text></g><g><title>[benchmark] (13 samples, 0.03%)</title><rect x="4.6594%" y="501" width="0.0333%" height="15" fill="rgb(216,164,2)" fg:x="1821" fg:w="13"/><text x="4.9094%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (13 samples, 0.03%)</title><rect x="4.6594%" y="485" width="0.0333%" height="15" fill="rgb(220,129,5)" fg:x="1821" fg:w="13"/><text x="4.9094%" y="495.50"></text></g><g><title>[libc.so.6] (88 samples, 0.23%)</title><rect x="4.6927%" y="501" width="0.2252%" height="15" fill="rgb(242,17,10)" fg:x="1834" fg:w="88"/><text x="4.9427%" y="511.50"></text></g><g><title>[libcrypto.so.3] (322 samples, 0.82%)</title><rect x="4.9179%" y="501" width="0.8239%" height="15" fill="rgb(242,107,0)" fg:x="1922" fg:w="322"/><text x="5.1679%" y="511.50"></text></g><g><title>__bss_start (11 samples, 0.03%)</title><rect x="5.7418%" y="501" width="0.0281%" height="15" fill="rgb(251,28,31)" fg:x="2244" fg:w="11"/><text x="5.9918%" y="511.50"></text></g><g><title>[libcrypto.so.3] (11 samples, 0.03%)</title><rect x="5.7418%" y="485" width="0.0281%" height="15" fill="rgb(233,223,10)" fg:x="2244" fg:w="11"/><text x="5.9918%" y="495.50"></text></g><g><title>__entry_text_start (39 samples, 0.10%)</title><rect x="6.0335%" y="309" width="0.0998%" height="15" fill="rgb(215,21,27)" fg:x="2358" fg:w="39"/><text x="6.2835%" y="319.50"></text></g><g><title>_copy_to_iter (4 samples, 0.01%)</title><rect x="6.1742%" y="261" width="0.0102%" height="15" fill="rgb(232,23,21)" fg:x="2413" fg:w="4"/><text x="6.4242%" y="271.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="6.3610%" y="85" width="0.0128%" height="15" fill="rgb(244,5,23)" fg:x="2486" fg:w="5"/><text x="6.6110%" y="95.50"></text></g><g><title>_copy_to_iter (37 samples, 0.09%)</title><rect x="6.2919%" y="245" width="0.0947%" height="15" fill="rgb(226,81,46)" fg:x="2459" fg:w="37"/><text x="6.5419%" y="255.50"></text></g><g><title>copyout (29 samples, 0.07%)</title><rect x="6.3124%" y="229" width="0.0742%" height="15" fill="rgb(247,70,30)" fg:x="2467" fg:w="29"/><text x="6.5624%" y="239.50"></text></g><g><title>asm_sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="6.3610%" y="213" width="0.0256%" height="15" fill="rgb(212,68,19)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="223.50"></text></g><g><title>sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="6.3610%" y="197" width="0.0256%" height="15" fill="rgb(240,187,13)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="207.50"></text></g><g><title>irqentry_exit (10 samples, 0.03%)</title><rect x="6.3610%" y="181" width="0.0256%" height="15" fill="rgb(223,113,26)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="191.50"></text></g><g><title>raw_irqentry_exit_cond_resched (10 samples, 0.03%)</title><rect x="6.3610%" y="165" width="0.0256%" height="15" fill="rgb(206,192,2)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="175.50"></text></g><g><title>preempt_schedule_irq (10 samples, 0.03%)</title><rect x="6.3610%" y="149" width="0.0256%" height="15" fill="rgb(241,108,4)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="159.50"></text></g><g><title>__schedule (10 samples, 0.03%)</title><rect x="6.3610%" y="133" width="0.0256%" height="15" fill="rgb(247,173,49)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="6.3610%" y="117" width="0.0256%" height="15" fill="rgb(224,114,35)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="6.3610%" y="101" width="0.0256%" height="15" fill="rgb(245,159,27)" fg:x="2486" fg:w="10"/><text x="6.6110%" y="111.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="6.3738%" y="85" width="0.0128%" height="15" fill="rgb(245,172,44)" fg:x="2491" fg:w="5"/><text x="6.6238%" y="95.50"></text></g><g><title>__memcpy (6 samples, 0.02%)</title><rect x="6.4301%" y="229" width="0.0154%" height="15" fill="rgb(236,23,11)" fg:x="2513" fg:w="6"/><text x="6.6801%" y="239.50"></text></g><g><title>chacha_block_generic (225 samples, 0.58%)</title><rect x="6.5171%" y="213" width="0.5757%" height="15" fill="rgb(205,117,38)" fg:x="2547" fg:w="225"/><text x="6.7671%" y="223.50"></text></g><g><title>chacha_permute (202 samples, 0.52%)</title><rect x="6.5759%" y="197" width="0.5169%" height="15" fill="rgb(237,72,25)" fg:x="2570" fg:w="202"/><text x="6.8259%" y="207.50"></text></g><g><title>__x64_sys_getrandom (367 samples, 0.94%)</title><rect x="6.1563%" y="277" width="0.9391%" height="15" fill="rgb(244,70,9)" fg:x="2406" fg:w="367"/><text x="6.4063%" y="287.50"></text></g><g><title>get_random_bytes_user (354 samples, 0.91%)</title><rect x="6.1896%" y="261" width="0.9058%" height="15" fill="rgb(217,125,39)" fg:x="2419" fg:w="354"/><text x="6.4396%" y="271.50"></text></g><g><title>crng_make_state (276 samples, 0.71%)</title><rect x="6.3891%" y="245" width="0.7062%" height="15" fill="rgb(235,36,10)" fg:x="2497" fg:w="276"/><text x="6.6391%" y="255.50"></text></g><g><title>crng_fast_key_erasure (253 samples, 0.65%)</title><rect x="6.4480%" y="229" width="0.6474%" height="15" fill="rgb(251,123,47)" fg:x="2520" fg:w="253"/><text x="6.6980%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (4 samples, 0.01%)</title><rect x="7.0953%" y="277" width="0.0102%" height="15" fill="rgb(221,13,13)" fg:x="2773" fg:w="4"/><text x="7.3453%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (13 samples, 0.03%)</title><rect x="7.1184%" y="261" width="0.0333%" height="15" fill="rgb(238,131,9)" fg:x="2782" fg:w="13"/><text x="7.3684%" y="271.50"></text></g><g><title>fpregs_assert_state_consistent (5 samples, 0.01%)</title><rect x="7.1388%" y="245" width="0.0128%" height="15" fill="rgb(211,50,8)" fg:x="2790" fg:w="5"/><text x="7.3888%" y="255.50"></text></g><g><title>do_syscall_64 (396 samples, 1.01%)</title><rect x="6.1461%" y="293" width="1.0133%" height="15" fill="rgb(245,182,24)" fg:x="2402" fg:w="396"/><text x="6.3961%" y="303.50"></text></g><g><title>syscall_exit_to_user_mode (21 samples, 0.05%)</title><rect x="7.1056%" y="277" width="0.0537%" height="15" fill="rgb(242,14,37)" fg:x="2777" fg:w="21"/><text x="7.3556%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (403 samples, 1.03%)</title><rect x="6.1384%" y="309" width="1.0312%" height="15" fill="rgb(246,228,12)" fg:x="2399" fg:w="403"/><text x="6.3884%" y="319.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::next_u64 (485 samples, 1.24%)</title><rect x="5.9567%" y="485" width="1.2410%" height="15" fill="rgb(213,55,15)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="495.50"></text></g><g><title>rand_core::impls::next_u64_via_fill (485 samples, 1.24%)</title><rect x="5.9567%" y="469" width="1.2410%" height="15" fill="rgb(209,9,3)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="479.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::fill_bytes (485 samples, 1.24%)</title><rect x="5.9567%" y="453" width="1.2410%" height="15" fill="rgb(230,59,30)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="463.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::try_fill_bytes (485 samples, 1.24%)</title><rect x="5.9567%" y="437" width="1.2410%" height="15" fill="rgb(209,121,21)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="447.50"></text></g><g><title>getrandom::getrandom (485 samples, 1.24%)</title><rect x="5.9567%" y="421" width="1.2410%" height="15" fill="rgb(220,109,13)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="431.50"></text></g><g><title>getrandom::getrandom_uninit (485 samples, 1.24%)</title><rect x="5.9567%" y="405" width="1.2410%" height="15" fill="rgb(232,18,1)" fg:x="2328" fg:w="485"/><text x="6.2067%" y="415.50"></text></g><g><title>getrandom::imp::getrandom_inner (484 samples, 1.24%)</title><rect x="5.9593%" y="389" width="1.2384%" height="15" fill="rgb(215,41,42)" fg:x="2329" fg:w="484"/><text x="6.2093%" y="399.50"></text></g><g><title>getrandom::util_libc::sys_fill_exact (484 samples, 1.24%)</title><rect x="5.9593%" y="373" width="1.2384%" height="15" fill="rgb(224,123,36)" fg:x="2329" fg:w="484"/><text x="6.2093%" y="383.50"></text></g><g><title>getrandom::imp::getrandom_inner::_{{closure}} (482 samples, 1.23%)</title><rect x="5.9644%" y="357" width="1.2333%" height="15" fill="rgb(240,125,3)" fg:x="2331" fg:w="482"/><text x="6.2144%" y="367.50"></text></g><g><title>getrandom::imp::getrandom (482 samples, 1.23%)</title><rect x="5.9644%" y="341" width="1.2333%" height="15" fill="rgb(205,98,50)" fg:x="2331" fg:w="482"/><text x="6.2144%" y="351.50"></text></g><g><title>syscall (482 samples, 1.23%)</title><rect x="5.9644%" y="325" width="1.2333%" height="15" fill="rgb(205,185,37)" fg:x="2331" fg:w="482"/><text x="6.2144%" y="335.50"></text></g><g><title>syscall_return_via_sysret (11 samples, 0.03%)</title><rect x="7.1695%" y="309" width="0.0281%" height="15" fill="rgb(238,207,15)" fg:x="2802" fg:w="11"/><text x="7.4195%" y="319.50"></text></g><g><title>[libc.so.6] (18 samples, 0.05%)</title><rect x="7.1977%" y="485" width="0.0461%" height="15" fill="rgb(213,199,42)" fg:x="2813" fg:w="18"/><text x="7.4477%" y="495.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (7 samples, 0.02%)</title><rect x="7.2540%" y="485" width="0.0179%" height="15" fill="rgb(235,201,11)" fg:x="2835" fg:w="7"/><text x="7.5040%" y="495.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="7.2540%" y="469" width="0.0179%" height="15" fill="rgb(207,46,11)" fg:x="2835" fg:w="7"/><text x="7.5040%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (6 samples, 0.02%)</title><rect x="7.2565%" y="453" width="0.0154%" height="15" fill="rgb(241,35,35)" fg:x="2836" fg:w="6"/><text x="7.5065%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_sub (6 samples, 0.02%)</title><rect x="7.2565%" y="437" width="0.0154%" height="15" fill="rgb(243,32,47)" fg:x="2836" fg:w="6"/><text x="7.5065%" y="447.50"></text></g><g><title>_ZN3std4sync4mpmc5array16Channel$LT$T$GT$10start_recv17h7800ca29c64cb868E.llvm.12455019271255371362 (7 samples, 0.02%)</title><rect x="7.3307%" y="437" width="0.0179%" height="15" fill="rgb(247,202,23)" fg:x="2865" fg:w="7"/><text x="7.5807%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map_err (5 samples, 0.01%)</title><rect x="7.3487%" y="437" width="0.0128%" height="15" fill="rgb(219,102,11)" fg:x="2872" fg:w="5"/><text x="7.5987%" y="447.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init (15 samples, 0.04%)</title><rect x="7.3614%" y="421" width="0.0384%" height="15" fill="rgb(243,110,44)" fg:x="2877" fg:w="15"/><text x="7.6114%" y="431.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (17 samples, 0.04%)</title><rect x="7.3614%" y="437" width="0.0435%" height="15" fill="rgb(222,74,54)" fg:x="2877" fg:w="17"/><text x="7.6114%" y="447.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::get_unchecked (8 samples, 0.02%)</title><rect x="7.4843%" y="421" width="0.0205%" height="15" fill="rgb(216,99,12)" fg:x="2925" fg:w="8"/><text x="7.7343%" y="431.50"></text></g><g><title>&lt;usize as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (8 samples, 0.02%)</title><rect x="7.4843%" y="405" width="0.0205%" height="15" fill="rgb(226,22,26)" fg:x="2925" fg:w="8"/><text x="7.7343%" y="415.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::add (8 samples, 0.02%)</title><rect x="7.4843%" y="389" width="0.0205%" height="15" fill="rgb(217,163,10)" fg:x="2925" fg:w="8"/><text x="7.7343%" y="399.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::offset (8 samples, 0.02%)</title><rect x="7.4843%" y="373" width="0.0205%" height="15" fill="rgb(213,25,53)" fg:x="2925" fg:w="8"/><text x="7.7343%" y="383.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (47 samples, 0.12%)</title><rect x="7.5047%" y="421" width="0.1203%" height="15" fill="rgb(252,105,26)" fg:x="2933" fg:w="47"/><text x="7.7547%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (47 samples, 0.12%)</title><rect x="7.5047%" y="405" width="0.1203%" height="15" fill="rgb(220,39,43)" fg:x="2933" fg:w="47"/><text x="7.7547%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (143 samples, 0.37%)</title><rect x="7.6250%" y="421" width="0.3659%" height="15" fill="rgb(229,68,48)" fg:x="2980" fg:w="143"/><text x="7.8750%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_load (143 samples, 0.37%)</title><rect x="7.6250%" y="405" width="0.3659%" height="15" fill="rgb(252,8,32)" fg:x="2980" fg:w="143"/><text x="7.8750%" y="415.50"></text></g><g><title>core::sync::atomic::fence (16 samples, 0.04%)</title><rect x="7.9909%" y="421" width="0.0409%" height="15" fill="rgb(223,20,43)" fg:x="3123" fg:w="16"/><text x="8.2409%" y="431.50"></text></g><g><title>std::sync::mpsc::Receiver&lt;T&gt;::try_recv (299 samples, 0.77%)</title><rect x="7.2744%" y="485" width="0.7651%" height="15" fill="rgb(229,81,49)" fg:x="2843" fg:w="299"/><text x="7.5244%" y="495.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::try_recv (299 samples, 0.77%)</title><rect x="7.2744%" y="469" width="0.7651%" height="15" fill="rgb(236,28,36)" fg:x="2843" fg:w="299"/><text x="7.5244%" y="479.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::try_recv (287 samples, 0.73%)</title><rect x="7.3052%" y="453" width="0.7344%" height="15" fill="rgb(249,185,26)" fg:x="2855" fg:w="287"/><text x="7.5552%" y="463.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (248 samples, 0.63%)</title><rect x="7.4049%" y="437" width="0.6346%" height="15" fill="rgb(249,174,33)" fg:x="2894" fg:w="248"/><text x="7.6549%" y="447.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (6 samples, 0.02%)</title><rect x="8.0395%" y="469" width="0.0154%" height="15" fill="rgb(233,201,37)" fg:x="3142" fg:w="6"/><text x="8.2895%" y="479.50"></text></g><g><title>std::time::Instant::duration_since (6 samples, 0.02%)</title><rect x="8.0395%" y="453" width="0.0154%" height="15" fill="rgb(221,78,26)" fg:x="3142" fg:w="6"/><text x="8.2895%" y="463.50"></text></g><g><title>std::time::Instant::checked_duration_since (5 samples, 0.01%)</title><rect x="8.0421%" y="437" width="0.0128%" height="15" fill="rgb(250,127,30)" fg:x="3143" fg:w="5"/><text x="8.2921%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (5 samples, 0.01%)</title><rect x="8.0421%" y="421" width="0.0128%" height="15" fill="rgb(230,49,44)" fg:x="3143" fg:w="5"/><text x="8.2921%" y="431.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (5 samples, 0.01%)</title><rect x="8.0421%" y="405" width="0.0128%" height="15" fill="rgb(229,67,23)" fg:x="3143" fg:w="5"/><text x="8.2921%" y="415.50"></text></g><g><title>std::time::Instant::elapsed (28 samples, 0.07%)</title><rect x="8.0395%" y="485" width="0.0716%" height="15" fill="rgb(249,83,47)" fg:x="3142" fg:w="28"/><text x="8.2895%" y="495.50"></text></g><g><title>std::time::Instant::now (22 samples, 0.06%)</title><rect x="8.0549%" y="469" width="0.0563%" height="15" fill="rgb(215,43,3)" fg:x="3148" fg:w="22"/><text x="8.3049%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::Instant::now (22 samples, 0.06%)</title><rect x="8.0549%" y="453" width="0.0563%" height="15" fill="rgb(238,154,13)" fg:x="3148" fg:w="22"/><text x="8.3049%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (22 samples, 0.06%)</title><rect x="8.0549%" y="437" width="0.0563%" height="15" fill="rgb(219,56,2)" fg:x="3148" fg:w="22"/><text x="8.3049%" y="447.50"></text></g><g><title>clock_gettime (21 samples, 0.05%)</title><rect x="8.0574%" y="421" width="0.0537%" height="15" fill="rgb(233,0,4)" fg:x="3149" fg:w="21"/><text x="8.3074%" y="431.50"></text></g><g><title>[[vdso]] (21 samples, 0.05%)</title><rect x="8.0574%" y="405" width="0.0537%" height="15" fill="rgb(235,30,7)" fg:x="3149" fg:w="21"/><text x="8.3074%" y="415.50"></text></g><g><title>[[vdso]] (17 samples, 0.04%)</title><rect x="8.0677%" y="389" width="0.0435%" height="15" fill="rgb(250,79,13)" fg:x="3153" fg:w="17"/><text x="8.3177%" y="399.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (386 samples, 0.99%)</title><rect x="8.2851%" y="469" width="0.9877%" height="15" fill="rgb(211,146,34)" fg:x="3238" fg:w="386"/><text x="8.5351%" y="479.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (386 samples, 0.99%)</title><rect x="8.2851%" y="453" width="0.9877%" height="15" fill="rgb(228,22,38)" fg:x="3238" fg:w="386"/><text x="8.5351%" y="463.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (386 samples, 0.99%)</title><rect x="8.2851%" y="437" width="0.9877%" height="15" fill="rgb(235,168,5)" fg:x="3238" fg:w="386"/><text x="8.5351%" y="447.50"></text></g><g><title>&lt;std::sync::mpmc::zero::ZeroToken as core::default::Default&gt;::default (4 samples, 0.01%)</title><rect x="9.2805%" y="469" width="0.0102%" height="15" fill="rgb(221,155,16)" fg:x="3627" fg:w="4"/><text x="9.5305%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (61 samples, 0.16%)</title><rect x="9.3112%" y="453" width="0.1561%" height="15" fill="rgb(215,215,53)" fg:x="3639" fg:w="61"/><text x="9.5612%" y="463.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (61 samples, 0.16%)</title><rect x="9.3112%" y="437" width="0.1561%" height="15" fill="rgb(223,4,10)" fg:x="3639" fg:w="61"/><text x="9.5612%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (58 samples, 0.15%)</title><rect x="9.3189%" y="421" width="0.1484%" height="15" fill="rgb(234,103,6)" fg:x="3642" fg:w="58"/><text x="9.5689%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (56 samples, 0.14%)</title><rect x="9.3240%" y="405" width="0.1433%" height="15" fill="rgb(227,97,0)" fg:x="3644" fg:w="56"/><text x="9.5740%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_swap (56 samples, 0.14%)</title><rect x="9.3240%" y="389" width="0.1433%" height="15" fill="rgb(234,150,53)" fg:x="3644" fg:w="56"/><text x="9.5740%" y="399.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (67 samples, 0.17%)</title><rect x="9.4673%" y="453" width="0.1714%" height="15" fill="rgb(228,201,54)" fg:x="3700" fg:w="67"/><text x="9.7173%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (66 samples, 0.17%)</title><rect x="9.4698%" y="437" width="0.1689%" height="15" fill="rgb(222,22,37)" fg:x="3701" fg:w="66"/><text x="9.7198%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (65 samples, 0.17%)</title><rect x="9.4724%" y="421" width="0.1663%" height="15" fill="rgb(237,53,32)" fg:x="3702" fg:w="65"/><text x="9.7224%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (65 samples, 0.17%)</title><rect x="9.4724%" y="405" width="0.1663%" height="15" fill="rgb(233,25,53)" fg:x="3702" fg:w="65"/><text x="9.7224%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_get_block_size (4 samples, 0.01%)</title><rect x="9.6924%" y="421" width="0.0102%" height="15" fill="rgb(210,40,34)" fg:x="3788" fg:w="4"/><text x="9.9424%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (362 samples, 0.93%)</title><rect x="9.2958%" y="469" width="0.9263%" height="15" fill="rgb(241,220,44)" fg:x="3633" fg:w="362"/><text x="9.5458%" y="479.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (228 samples, 0.58%)</title><rect x="9.6387%" y="453" width="0.5834%" height="15" fill="rgb(235,28,35)" fg:x="3767" fg:w="228"/><text x="9.8887%" y="463.50"></text></g><g><title>EVP_DecryptUpdate (221 samples, 0.57%)</title><rect x="9.6566%" y="437" width="0.5655%" height="15" fill="rgb(210,56,17)" fg:x="3774" fg:w="221"/><text x="9.9066%" y="447.50"></text></g><g><title>[libcrypto.so.3] (203 samples, 0.52%)</title><rect x="9.7027%" y="421" width="0.5194%" height="15" fill="rgb(224,130,29)" fg:x="3792" fg:w="203"/><text x="9.9527%" y="431.50"></text></g><g><title>[libcrypto.so.3] (148 samples, 0.38%)</title><rect x="9.8434%" y="405" width="0.3787%" height="15" fill="rgb(235,212,8)" fg:x="3847" fg:w="148"/><text x="10.0934%" y="415.50"></text></g><g><title>[libcrypto.so.3] (137 samples, 0.35%)</title><rect x="9.8716%" y="389" width="0.3505%" height="15" fill="rgb(223,33,50)" fg:x="3858" fg:w="137"/><text x="10.1216%" y="399.50"></text></g><g><title>__rust_probestack (8 samples, 0.02%)</title><rect x="10.2221%" y="469" width="0.0205%" height="15" fill="rgb(219,149,13)" fg:x="3995" fg:w="8"/><text x="10.4721%" y="479.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade::_{{closure}} (5 samples, 0.01%)</title><rect x="10.2809%" y="405" width="0.0128%" height="15" fill="rgb(250,156,29)" fg:x="4018" fg:w="5"/><text x="10.5309%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (54 samples, 0.14%)</title><rect x="10.2937%" y="405" width="0.1382%" height="15" fill="rgb(216,193,19)" fg:x="4023" fg:w="54"/><text x="10.5437%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (54 samples, 0.14%)</title><rect x="10.2937%" y="389" width="0.1382%" height="15" fill="rgb(216,135,14)" fg:x="4023" fg:w="54"/><text x="10.5437%" y="399.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade (78 samples, 0.20%)</title><rect x="10.2554%" y="437" width="0.1996%" height="15" fill="rgb(241,47,5)" fg:x="4008" fg:w="78"/><text x="10.5054%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_update (72 samples, 0.18%)</title><rect x="10.2707%" y="421" width="0.1842%" height="15" fill="rgb(233,42,35)" fg:x="4014" fg:w="72"/><text x="10.5207%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (9 samples, 0.02%)</title><rect x="10.4319%" y="405" width="0.0230%" height="15" fill="rgb(231,13,6)" fg:x="4077" fg:w="9"/><text x="10.6819%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (9 samples, 0.02%)</title><rect x="10.4319%" y="389" width="0.0230%" height="15" fill="rgb(207,181,40)" fg:x="4077" fg:w="9"/><text x="10.6819%" y="399.50"></text></g><g><title>core::option::Option&lt;T&gt;::map (82 samples, 0.21%)</title><rect x="10.2554%" y="469" width="0.2098%" height="15" fill="rgb(254,173,49)" fg:x="4008" fg:w="82"/><text x="10.5054%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive::_{{closure}} (82 samples, 0.21%)</title><rect x="10.2554%" y="453" width="0.2098%" height="15" fill="rgb(221,1,38)" fg:x="4008" fg:w="82"/><text x="10.5054%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (4 samples, 0.01%)</title><rect x="10.4549%" y="437" width="0.0102%" height="15" fill="rgb(206,124,46)" fg:x="4086" fg:w="4"/><text x="10.7049%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (59 samples, 0.15%)</title><rect x="10.4652%" y="469" width="0.1510%" height="15" fill="rgb(249,21,11)" fg:x="4090" fg:w="59"/><text x="10.7152%" y="479.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (59 samples, 0.15%)</title><rect x="10.4652%" y="453" width="0.1510%" height="15" fill="rgb(222,201,40)" fg:x="4090" fg:w="59"/><text x="10.7152%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (54 samples, 0.14%)</title><rect x="10.4780%" y="437" width="0.1382%" height="15" fill="rgb(235,61,29)" fg:x="4095" fg:w="54"/><text x="10.7280%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_sub (54 samples, 0.14%)</title><rect x="10.4780%" y="421" width="0.1382%" height="15" fill="rgb(219,207,3)" fg:x="4095" fg:w="54"/><text x="10.7280%" y="431.50"></text></g><g><title>[libc.so.6] (33 samples, 0.08%)</title><rect x="11.5501%" y="261" width="0.0844%" height="15" fill="rgb(222,56,46)" fg:x="4514" fg:w="33"/><text x="11.8001%" y="271.50"></text></g><g><title>__entry_text_start (6 samples, 0.02%)</title><rect x="11.7266%" y="245" width="0.0154%" height="15" fill="rgb(239,76,54)" fg:x="4583" fg:w="6"/><text x="11.9766%" y="255.50"></text></g><g><title>futex_unqueue (8 samples, 0.02%)</title><rect x="11.7804%" y="165" width="0.0205%" height="15" fill="rgb(231,124,27)" fg:x="4604" fg:w="8"/><text x="12.0304%" y="175.50"></text></g><g><title>update_curr (13 samples, 0.03%)</title><rect x="11.8725%" y="69" width="0.0333%" height="15" fill="rgb(249,195,6)" fg:x="4640" fg:w="13"/><text x="12.1225%" y="79.50"></text></g><g><title>cpuacct_charge (4 samples, 0.01%)</title><rect x="11.8955%" y="53" width="0.0102%" height="15" fill="rgb(237,174,47)" fg:x="4649" fg:w="4"/><text x="12.1455%" y="63.50"></text></g><g><title>dequeue_task (24 samples, 0.06%)</title><rect x="11.8571%" y="117" width="0.0614%" height="15" fill="rgb(206,201,31)" fg:x="4634" fg:w="24"/><text x="12.1071%" y="127.50"></text></g><g><title>dequeue_task_fair (24 samples, 0.06%)</title><rect x="11.8571%" y="101" width="0.0614%" height="15" fill="rgb(231,57,52)" fg:x="4634" fg:w="24"/><text x="12.1071%" y="111.50"></text></g><g><title>dequeue_entity (24 samples, 0.06%)</title><rect x="11.8571%" y="85" width="0.0614%" height="15" fill="rgb(248,177,22)" fg:x="4634" fg:w="24"/><text x="12.1071%" y="95.50"></text></g><g><title>finish_task_switch.isra.0 (12 samples, 0.03%)</title><rect x="11.9185%" y="117" width="0.0307%" height="15" fill="rgb(215,211,37)" fg:x="4658" fg:w="12"/><text x="12.1685%" y="127.50"></text></g><g><title>raw_spin_rq_unlock (7 samples, 0.02%)</title><rect x="11.9313%" y="101" width="0.0179%" height="15" fill="rgb(241,128,51)" fg:x="4663" fg:w="7"/><text x="12.1813%" y="111.50"></text></g><g><title>prepare_task_switch (14 samples, 0.04%)</title><rect x="11.9518%" y="117" width="0.0358%" height="15" fill="rgb(227,165,31)" fg:x="4671" fg:w="14"/><text x="12.2018%" y="127.50"></text></g><g><title>__perf_event_task_sched_out (4 samples, 0.01%)</title><rect x="11.9774%" y="101" width="0.0102%" height="15" fill="rgb(228,167,24)" fg:x="4681" fg:w="4"/><text x="12.2274%" y="111.50"></text></g><g><title>psi_group_change (16 samples, 0.04%)</title><rect x="12.0106%" y="101" width="0.0409%" height="15" fill="rgb(228,143,12)" fg:x="4694" fg:w="16"/><text x="12.2606%" y="111.50"></text></g><g><title>psi_task_switch (31 samples, 0.08%)</title><rect x="11.9902%" y="117" width="0.0793%" height="15" fill="rgb(249,149,8)" fg:x="4686" fg:w="31"/><text x="12.2402%" y="127.50"></text></g><g><title>sched_clock_cpu (6 samples, 0.02%)</title><rect x="12.0541%" y="101" width="0.0154%" height="15" fill="rgb(243,35,44)" fg:x="4711" fg:w="6"/><text x="12.3041%" y="111.50"></text></g><g><title>__schedule (97 samples, 0.25%)</title><rect x="11.8264%" y="133" width="0.2482%" height="15" fill="rgb(246,89,9)" fg:x="4622" fg:w="97"/><text x="12.0764%" y="143.50"></text></g><g><title>futex_wait_queue (109 samples, 0.28%)</title><rect x="11.8008%" y="165" width="0.2789%" height="15" fill="rgb(233,213,13)" fg:x="4612" fg:w="109"/><text x="12.0508%" y="175.50"></text></g><g><title>schedule (102 samples, 0.26%)</title><rect x="11.8187%" y="149" width="0.2610%" height="15" fill="rgb(233,141,41)" fg:x="4619" fg:w="102"/><text x="12.0687%" y="159.50"></text></g><g><title>__get_user_nocheck_4 (11 samples, 0.03%)</title><rect x="12.0848%" y="149" width="0.0281%" height="15" fill="rgb(239,167,4)" fg:x="4723" fg:w="11"/><text x="12.3348%" y="159.50"></text></g><g><title>futex_q_lock (4 samples, 0.01%)</title><rect x="12.1258%" y="149" width="0.0102%" height="15" fill="rgb(209,217,16)" fg:x="4739" fg:w="4"/><text x="12.3758%" y="159.50"></text></g><g><title>futex_q_unlock (4 samples, 0.01%)</title><rect x="12.1360%" y="149" width="0.0102%" height="15" fill="rgb(219,88,35)" fg:x="4743" fg:w="4"/><text x="12.3860%" y="159.50"></text></g><g><title>futex_wait_setup (28 samples, 0.07%)</title><rect x="12.0797%" y="165" width="0.0716%" height="15" fill="rgb(220,193,23)" fg:x="4721" fg:w="28"/><text x="12.3297%" y="175.50"></text></g><g><title>__x64_sys_futex (156 samples, 0.40%)</title><rect x="11.7548%" y="213" width="0.3992%" height="15" fill="rgb(230,90,52)" fg:x="4594" fg:w="156"/><text x="12.0048%" y="223.50"></text></g><g><title>do_futex (154 samples, 0.39%)</title><rect x="11.7599%" y="197" width="0.3940%" height="15" fill="rgb(252,106,19)" fg:x="4596" fg:w="154"/><text x="12.0099%" y="207.50"></text></g><g><title>futex_wait (153 samples, 0.39%)</title><rect x="11.7624%" y="181" width="0.3915%" height="15" fill="rgb(206,74,20)" fg:x="4597" fg:w="153"/><text x="12.0124%" y="191.50"></text></g><g><title>__rseq_handle_notify_resume (10 samples, 0.03%)</title><rect x="12.1795%" y="165" width="0.0256%" height="15" fill="rgb(230,138,44)" fg:x="4760" fg:w="10"/><text x="12.4295%" y="175.50"></text></g><g><title>exit_to_user_mode_loop (17 samples, 0.04%)</title><rect x="12.1642%" y="181" width="0.0435%" height="15" fill="rgb(235,182,43)" fg:x="4754" fg:w="17"/><text x="12.4142%" y="191.50"></text></g><g><title>do_syscall_64 (183 samples, 0.47%)</title><rect x="11.7445%" y="229" width="0.4682%" height="15" fill="rgb(242,16,51)" fg:x="4590" fg:w="183"/><text x="11.9945%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (22 samples, 0.06%)</title><rect x="12.1565%" y="213" width="0.0563%" height="15" fill="rgb(248,9,4)" fg:x="4751" fg:w="22"/><text x="12.4065%" y="223.50"></text></g><g><title>exit_to_user_mode_prepare (22 samples, 0.06%)</title><rect x="12.1565%" y="197" width="0.0563%" height="15" fill="rgb(210,31,22)" fg:x="4751" fg:w="22"/><text x="12.4065%" y="207.50"></text></g><g><title>__lll_lock_wait_private (227 samples, 0.58%)</title><rect x="11.6345%" y="261" width="0.5808%" height="15" fill="rgb(239,54,39)" fg:x="4547" fg:w="227"/><text x="11.8845%" y="271.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (185 samples, 0.47%)</title><rect x="11.7420%" y="245" width="0.4734%" height="15" fill="rgb(230,99,41)" fg:x="4589" fg:w="185"/><text x="11.9920%" y="255.50"></text></g><g><title>[libc.so.6] (583 samples, 1.49%)</title><rect x="10.7262%" y="277" width="1.4917%" height="15" fill="rgb(253,106,12)" fg:x="4192" fg:w="583"/><text x="10.9762%" y="287.50"></text></g><g><title>__entry_text_start (7 samples, 0.02%)</title><rect x="12.2256%" y="261" width="0.0179%" height="15" fill="rgb(213,46,41)" fg:x="4778" fg:w="7"/><text x="12.4756%" y="271.50"></text></g><g><title>__x64_sys_futex (6 samples, 0.02%)</title><rect x="12.2486%" y="245" width="0.0154%" height="15" fill="rgb(215,133,35)" fg:x="4787" fg:w="6"/><text x="12.4986%" y="255.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="12.2512%" y="229" width="0.0128%" height="15" fill="rgb(213,28,5)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="239.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="12.2512%" y="213" width="0.0128%" height="15" fill="rgb(215,77,49)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="223.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="12.2512%" y="197" width="0.0128%" height="15" fill="rgb(248,100,22)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="207.50"></text></g><g><title>raw_irqentry_exit_cond_resched (5 samples, 0.01%)</title><rect x="12.2512%" y="181" width="0.0128%" height="15" fill="rgb(208,67,9)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="191.50"></text></g><g><title>preempt_schedule_irq (5 samples, 0.01%)</title><rect x="12.2512%" y="165" width="0.0128%" height="15" fill="rgb(219,133,21)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="175.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="12.2512%" y="149" width="0.0128%" height="15" fill="rgb(246,46,29)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="159.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="12.2512%" y="133" width="0.0128%" height="15" fill="rgb(246,185,52)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="143.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="12.2512%" y="117" width="0.0128%" height="15" fill="rgb(252,136,11)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="127.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="12.2512%" y="101" width="0.0128%" height="15" fill="rgb(219,138,53)" fg:x="4788" fg:w="5"/><text x="12.5012%" y="111.50"></text></g><g><title>_raw_spin_lock (8 samples, 0.02%)</title><rect x="12.2793%" y="197" width="0.0205%" height="15" fill="rgb(211,51,23)" fg:x="4799" fg:w="8"/><text x="12.5293%" y="207.50"></text></g><g><title>futex_hash (4 samples, 0.01%)</title><rect x="12.2998%" y="197" width="0.0102%" height="15" fill="rgb(247,221,28)" fg:x="4807" fg:w="4"/><text x="12.5498%" y="207.50"></text></g><g><title>_raw_spin_lock (18 samples, 0.05%)</title><rect x="12.3842%" y="181" width="0.0461%" height="15" fill="rgb(251,222,45)" fg:x="4840" fg:w="18"/><text x="12.6342%" y="191.50"></text></g><g><title>native_queued_spin_lock_slowpath (18 samples, 0.05%)</title><rect x="12.3842%" y="165" width="0.0461%" height="15" fill="rgb(217,162,53)" fg:x="4840" fg:w="18"/><text x="12.6342%" y="175.50"></text></g><g><title>get_futex_key (4 samples, 0.01%)</title><rect x="12.4303%" y="181" width="0.0102%" height="15" fill="rgb(229,93,14)" fg:x="4858" fg:w="4"/><text x="12.6803%" y="191.50"></text></g><g><title>futex_wake (53 samples, 0.14%)</title><rect x="12.3100%" y="197" width="0.1356%" height="15" fill="rgb(209,67,49)" fg:x="4811" fg:w="53"/><text x="12.5600%" y="207.50"></text></g><g><title>__x64_sys_futex (71 samples, 0.18%)</title><rect x="12.2665%" y="229" width="0.1817%" height="15" fill="rgb(213,87,29)" fg:x="4794" fg:w="71"/><text x="12.5165%" y="239.50"></text></g><g><title>do_futex (68 samples, 0.17%)</title><rect x="12.2742%" y="213" width="0.1740%" height="15" fill="rgb(205,151,52)" fg:x="4797" fg:w="68"/><text x="12.5242%" y="223.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="12.4687%" y="197" width="0.0128%" height="15" fill="rgb(253,215,39)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="207.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="12.4687%" y="181" width="0.0128%" height="15" fill="rgb(221,220,41)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="191.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="12.4687%" y="165" width="0.0128%" height="15" fill="rgb(218,133,21)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="175.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="12.4687%" y="149" width="0.0128%" height="15" fill="rgb(221,193,43)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="159.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="12.4687%" y="133" width="0.0128%" height="15" fill="rgb(240,128,52)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="143.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="12.4687%" y="117" width="0.0128%" height="15" fill="rgb(253,114,12)" fg:x="4873" fg:w="5"/><text x="12.7187%" y="127.50"></text></g><g><title>do_syscall_64 (86 samples, 0.22%)</title><rect x="12.2640%" y="245" width="0.2201%" height="15" fill="rgb(215,223,47)" fg:x="4793" fg:w="86"/><text x="12.5140%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (14 samples, 0.04%)</title><rect x="12.4482%" y="229" width="0.0358%" height="15" fill="rgb(248,225,23)" fg:x="4865" fg:w="14"/><text x="12.6982%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (13 samples, 0.03%)</title><rect x="12.4507%" y="213" width="0.0333%" height="15" fill="rgb(250,108,0)" fg:x="4866" fg:w="13"/><text x="12.7007%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (94 samples, 0.24%)</title><rect x="12.2460%" y="261" width="0.2405%" height="15" fill="rgb(228,208,7)" fg:x="4786" fg:w="94"/><text x="12.4960%" y="271.50"></text></g><g><title>alloc::alloc::dealloc (730 samples, 1.87%)</title><rect x="10.6213%" y="309" width="1.8679%" height="15" fill="rgb(244,45,10)" fg:x="4151" fg:w="730"/><text x="10.8713%" y="319.50">a..</text></g><g><title>cfree (727 samples, 1.86%)</title><rect x="10.6289%" y="293" width="1.8602%" height="15" fill="rgb(207,125,25)" fg:x="4154" fg:w="727"/><text x="10.8789%" y="303.50">c..</text></g><g><title>__lll_lock_wake_private (106 samples, 0.27%)</title><rect x="12.2179%" y="277" width="0.2712%" height="15" fill="rgb(210,195,18)" fg:x="4775" fg:w="106"/><text x="12.4679%" y="287.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (732 samples, 1.87%)</title><rect x="10.6213%" y="325" width="1.8730%" height="15" fill="rgb(249,80,12)" fg:x="4151" fg:w="732"/><text x="10.8713%" y="335.50">&lt;..</text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (738 samples, 1.89%)</title><rect x="10.6161%" y="469" width="1.8883%" height="15" fill="rgb(221,65,9)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="479.50">c..</text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (738 samples, 1.89%)</title><rect x="10.6161%" y="453" width="1.8883%" height="15" fill="rgb(235,49,36)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="463.50">&lt;..</text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (738 samples, 1.89%)</title><rect x="10.6161%" y="437" width="1.8883%" height="15" fill="rgb(225,32,20)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="447.50">a..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (738 samples, 1.89%)</title><rect x="10.6161%" y="421" width="1.8883%" height="15" fill="rgb(215,141,46)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="431.50">a..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (738 samples, 1.89%)</title><rect x="10.6161%" y="405" width="1.8883%" height="15" fill="rgb(250,160,47)" fg:x="4149" fg:w="738"/><text x="10.8661%" y="415.50">a..</text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (736 samples, 1.88%)</title><rect x="10.6213%" y="389" width="1.8832%" height="15" fill="rgb(216,222,40)" fg:x="4151" fg:w="736"/><text x="10.8713%" y="399.50">c..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (736 samples, 1.88%)</title><rect x="10.6213%" y="373" width="1.8832%" height="15" fill="rgb(234,217,39)" fg:x="4151" fg:w="736"/><text x="10.8713%" y="383.50">c..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (736 samples, 1.88%)</title><rect x="10.6213%" y="357" width="1.8832%" height="15" fill="rgb(207,178,40)" fg:x="4151" fg:w="736"/><text x="10.8713%" y="367.50">c..</text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (736 samples, 1.88%)</title><rect x="10.6213%" y="341" width="1.8832%" height="15" fill="rgb(221,136,13)" fg:x="4151" fg:w="736"/><text x="10.8713%" y="351.50">&lt;..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::current_memory (4 samples, 0.01%)</title><rect x="12.4942%" y="325" width="0.0102%" height="15" fill="rgb(249,199,10)" fg:x="4883" fg:w="4"/><text x="12.7442%" y="335.50"></text></g><g><title>std::sync::poison::Flag::done (9 samples, 0.02%)</title><rect x="12.5045%" y="437" width="0.0230%" height="15" fill="rgb(249,222,13)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="447.50"></text></g><g><title>std::thread::panicking (9 samples, 0.02%)</title><rect x="12.5045%" y="421" width="0.0230%" height="15" fill="rgb(244,185,38)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="431.50"></text></g><g><title>std::panicking::panicking (9 samples, 0.02%)</title><rect x="12.5045%" y="405" width="0.0230%" height="15" fill="rgb(236,202,9)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="415.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (9 samples, 0.02%)</title><rect x="12.5045%" y="389" width="0.0230%" height="15" fill="rgb(250,229,37)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (9 samples, 0.02%)</title><rect x="12.5045%" y="373" width="0.0230%" height="15" fill="rgb(206,174,23)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (9 samples, 0.02%)</title><rect x="12.5045%" y="357" width="0.0230%" height="15" fill="rgb(211,33,43)" fg:x="4887" fg:w="9"/><text x="12.7545%" y="367.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (76 samples, 0.19%)</title><rect x="12.5045%" y="453" width="0.1945%" height="15" fill="rgb(245,58,50)" fg:x="4887" fg:w="76"/><text x="12.7545%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (67 samples, 0.17%)</title><rect x="12.5275%" y="437" width="0.1714%" height="15" fill="rgb(244,68,36)" fg:x="4896" fg:w="67"/><text x="12.7775%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (65 samples, 0.17%)</title><rect x="12.5326%" y="421" width="0.1663%" height="15" fill="rgb(232,229,15)" fg:x="4898" fg:w="65"/><text x="12.7826%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_swap (65 samples, 0.17%)</title><rect x="12.5326%" y="405" width="0.1663%" height="15" fill="rgb(254,30,23)" fg:x="4898" fg:w="65"/><text x="12.7826%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (77 samples, 0.20%)</title><rect x="12.5045%" y="469" width="0.1970%" height="15" fill="rgb(235,160,14)" fg:x="4887" fg:w="77"/><text x="12.7545%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;std::collections::hash::map::HashMap&lt;core::num::nonzero::NonZeroU32,alloc::sync::Weak&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt;&gt;&gt; (77 samples, 0.20%)</title><rect x="12.7015%" y="469" width="0.1970%" height="15" fill="rgb(212,155,44)" fg:x="4964" fg:w="77"/><text x="12.9515%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (77 samples, 0.20%)</title><rect x="12.7015%" y="453" width="0.1970%" height="15" fill="rgb(226,2,50)" fg:x="4964" fg:w="77"/><text x="12.9515%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (77 samples, 0.20%)</title><rect x="12.7015%" y="437" width="0.1970%" height="15" fill="rgb(234,177,6)" fg:x="4964" fg:w="77"/><text x="12.9515%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (70 samples, 0.18%)</title><rect x="12.7194%" y="421" width="0.1791%" height="15" fill="rgb(217,24,9)" fg:x="4971" fg:w="70"/><text x="12.9694%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (70 samples, 0.18%)</title><rect x="12.7194%" y="405" width="0.1791%" height="15" fill="rgb(220,13,46)" fg:x="4971" fg:w="70"/><text x="12.9694%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (51 samples, 0.13%)</title><rect x="12.8985%" y="469" width="0.1305%" height="15" fill="rgb(239,221,27)" fg:x="5041" fg:w="51"/><text x="13.1485%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (51 samples, 0.13%)</title><rect x="12.8985%" y="453" width="0.1305%" height="15" fill="rgb(222,198,25)" fg:x="5041" fg:w="51"/><text x="13.1485%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (51 samples, 0.13%)</title><rect x="12.8985%" y="437" width="0.1305%" height="15" fill="rgb(211,99,13)" fg:x="5041" fg:w="51"/><text x="13.1485%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (48 samples, 0.12%)</title><rect x="12.9062%" y="421" width="0.1228%" height="15" fill="rgb(232,111,31)" fg:x="5044" fg:w="48"/><text x="13.1562%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (48 samples, 0.12%)</title><rect x="12.9062%" y="405" width="0.1228%" height="15" fill="rgb(245,82,37)" fg:x="5044" fg:w="48"/><text x="13.1562%" y="415.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::c_rounds (7 samples, 0.02%)</title><rect x="13.0674%" y="341" width="0.0179%" height="15" fill="rgb(227,149,46)" fg:x="5107" fg:w="7"/><text x="13.3174%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (6 samples, 0.02%)</title><rect x="13.0700%" y="325" width="0.0154%" height="15" fill="rgb(218,36,50)" fg:x="5108" fg:w="6"/><text x="13.3200%" y="335.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (14 samples, 0.04%)</title><rect x="13.1032%" y="325" width="0.0358%" height="15" fill="rgb(226,80,48)" fg:x="5121" fg:w="14"/><text x="13.3532%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="13.0418%" y="389" width="0.1305%" height="15" fill="rgb(238,224,15)" fg:x="5097" fg:w="51"/><text x="13.2918%" y="399.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="13.0418%" y="373" width="0.1305%" height="15" fill="rgb(241,136,10)" fg:x="5097" fg:w="51"/><text x="13.2918%" y="383.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="13.0418%" y="357" width="0.1305%" height="15" fill="rgb(208,32,45)" fg:x="5097" fg:w="51"/><text x="13.2918%" y="367.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::d_rounds (34 samples, 0.09%)</title><rect x="13.0853%" y="341" width="0.0870%" height="15" fill="rgb(207,135,9)" fg:x="5114" fg:w="34"/><text x="13.3353%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (13 samples, 0.03%)</title><rect x="13.1390%" y="325" width="0.0333%" height="15" fill="rgb(206,86,44)" fg:x="5135" fg:w="13"/><text x="13.3890%" y="335.50"></text></g><g><title>hashbrown::map::make_hash (70 samples, 0.18%)</title><rect x="13.0341%" y="421" width="0.1791%" height="15" fill="rgb(245,177,15)" fg:x="5094" fg:w="70"/><text x="13.2841%" y="431.50"></text></g><g><title>core::hash::BuildHasher::hash_one (70 samples, 0.18%)</title><rect x="13.0341%" y="405" width="0.1791%" height="15" fill="rgb(206,64,50)" fg:x="5094" fg:w="70"/><text x="13.2841%" y="415.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (14 samples, 0.04%)</title><rect x="13.1774%" y="389" width="0.0358%" height="15" fill="rgb(234,36,40)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="399.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (14 samples, 0.04%)</title><rect x="13.1774%" y="373" width="0.0358%" height="15" fill="rgb(213,64,8)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="383.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for u32&gt;::hash (14 samples, 0.04%)</title><rect x="13.1774%" y="357" width="0.0358%" height="15" fill="rgb(210,75,36)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="367.50"></text></g><g><title>core::hash::Hasher::write_u32 (14 samples, 0.04%)</title><rect x="13.1774%" y="341" width="0.0358%" height="15" fill="rgb(229,88,21)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="351.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::write (14 samples, 0.04%)</title><rect x="13.1774%" y="325" width="0.0358%" height="15" fill="rgb(252,204,47)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="335.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::write (14 samples, 0.04%)</title><rect x="13.1774%" y="309" width="0.0358%" height="15" fill="rgb(208,77,27)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="319.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::write (14 samples, 0.04%)</title><rect x="13.1774%" y="293" width="0.0358%" height="15" fill="rgb(221,76,26)" fg:x="5150" fg:w="14"/><text x="13.4274%" y="303.50"></text></g><g><title>core::hash::sip::u8to64_le (11 samples, 0.03%)</title><rect x="13.1851%" y="277" width="0.0281%" height="15" fill="rgb(225,139,18)" fg:x="5153" fg:w="11"/><text x="13.4351%" y="287.50"></text></g><g><title>&lt;hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator&gt;::next (4 samples, 0.01%)</title><rect x="13.2260%" y="373" width="0.0102%" height="15" fill="rgb(230,137,11)" fg:x="5169" fg:w="4"/><text x="13.4760%" y="383.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find::_{{closure}} (8 samples, 0.02%)</title><rect x="13.2363%" y="373" width="0.0205%" height="15" fill="rgb(212,28,1)" fg:x="5173" fg:w="8"/><text x="13.4863%" y="383.50"></text></g><g><title>hashbrown::map::equivalent_key::_{{closure}} (8 samples, 0.02%)</title><rect x="13.2363%" y="357" width="0.0205%" height="15" fill="rgb(248,164,17)" fg:x="5173" fg:w="8"/><text x="13.4863%" y="367.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::cmp::PartialEq&gt;::eq (8 samples, 0.02%)</title><rect x="13.2363%" y="341" width="0.0205%" height="15" fill="rgb(222,171,42)" fg:x="5173" fg:w="8"/><text x="13.4863%" y="351.50"></text></g><g><title>hashbrown::raw::h2 (9 samples, 0.02%)</title><rect x="13.2567%" y="373" width="0.0230%" height="15" fill="rgb(243,84,45)" fg:x="5181" fg:w="9"/><text x="13.5067%" y="383.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (109 samples, 0.28%)</title><rect x="13.0341%" y="437" width="0.2789%" height="15" fill="rgb(252,49,23)" fg:x="5094" fg:w="109"/><text x="13.2841%" y="447.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::get (39 samples, 0.10%)</title><rect x="13.2132%" y="421" width="0.0998%" height="15" fill="rgb(215,19,7)" fg:x="5164" fg:w="39"/><text x="13.4632%" y="431.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find (39 samples, 0.10%)</title><rect x="13.2132%" y="405" width="0.0998%" height="15" fill="rgb(238,81,41)" fg:x="5164" fg:w="39"/><text x="13.4632%" y="415.50"></text></g><g><title>hashbrown::raw::RawTableInner&lt;A&gt;::find_inner (39 samples, 0.10%)</title><rect x="13.2132%" y="389" width="0.0998%" height="15" fill="rgb(210,199,37)" fg:x="5164" fg:w="39"/><text x="13.4632%" y="399.50"></text></g><g><title>hashbrown::raw::sse2::Group::load (13 samples, 0.03%)</title><rect x="13.2798%" y="373" width="0.0333%" height="15" fill="rgb(244,192,49)" fg:x="5190" fg:w="13"/><text x="13.5298%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_loadu_si128 (13 samples, 0.03%)</title><rect x="13.2798%" y="357" width="0.0333%" height="15" fill="rgb(226,211,11)" fg:x="5190" fg:w="13"/><text x="13.5298%" y="367.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (13 samples, 0.03%)</title><rect x="13.2798%" y="341" width="0.0333%" height="15" fill="rgb(236,162,54)" fg:x="5190" fg:w="13"/><text x="13.5298%" y="351.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (113 samples, 0.29%)</title><rect x="13.0341%" y="469" width="0.2891%" height="15" fill="rgb(220,229,9)" fg:x="5094" fg:w="113"/><text x="13.2841%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (113 samples, 0.29%)</title><rect x="13.0341%" y="453" width="0.2891%" height="15" fill="rgb(250,87,22)" fg:x="5094" fg:w="113"/><text x="13.2841%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (4 samples, 0.01%)</title><rect x="13.3130%" y="437" width="0.0102%" height="15" fill="rgb(239,43,17)" fg:x="5203" fg:w="4"/><text x="13.5630%" y="447.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (6 samples, 0.02%)</title><rect x="13.3233%" y="437" width="0.0154%" height="15" fill="rgb(231,177,25)" fg:x="5207" fg:w="6"/><text x="13.5733%" y="447.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (14 samples, 0.04%)</title><rect x="13.3233%" y="453" width="0.0358%" height="15" fill="rgb(219,179,1)" fg:x="5207" fg:w="14"/><text x="13.5733%" y="463.50"></text></g><g><title>std::sync::poison::Flag::guard (8 samples, 0.02%)</title><rect x="13.3386%" y="437" width="0.0205%" height="15" fill="rgb(238,219,53)" fg:x="5213" fg:w="8"/><text x="13.5886%" y="447.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (47 samples, 0.12%)</title><rect x="13.3233%" y="469" width="0.1203%" height="15" fill="rgb(232,167,36)" fg:x="5207" fg:w="47"/><text x="13.5733%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (33 samples, 0.08%)</title><rect x="13.3591%" y="453" width="0.0844%" height="15" fill="rgb(244,19,51)" fg:x="5221" fg:w="33"/><text x="13.6091%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (32 samples, 0.08%)</title><rect x="13.3616%" y="437" width="0.0819%" height="15" fill="rgb(224,6,22)" fg:x="5222" fg:w="32"/><text x="13.6116%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (32 samples, 0.08%)</title><rect x="13.3616%" y="421" width="0.0819%" height="15" fill="rgb(224,145,5)" fg:x="5222" fg:w="32"/><text x="13.6116%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (117 samples, 0.30%)</title><rect x="13.4870%" y="437" width="0.2994%" height="15" fill="rgb(234,130,49)" fg:x="5271" fg:w="117"/><text x="13.7370%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (117 samples, 0.30%)</title><rect x="13.4870%" y="421" width="0.2994%" height="15" fill="rgb(254,6,2)" fg:x="5271" fg:w="117"/><text x="13.7370%" y="431.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (140 samples, 0.36%)</title><rect x="13.4435%" y="469" width="0.3582%" height="15" fill="rgb(208,96,46)" fg:x="5254" fg:w="140"/><text x="13.6935%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (140 samples, 0.36%)</title><rect x="13.4435%" y="453" width="0.3582%" height="15" fill="rgb(239,3,39)" fg:x="5254" fg:w="140"/><text x="13.6935%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::is_read_lockable (6 samples, 0.02%)</title><rect x="13.7864%" y="437" width="0.0154%" height="15" fill="rgb(233,210,1)" fg:x="5388" fg:w="6"/><text x="14.0364%" y="447.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::check (7 samples, 0.02%)</title><rect x="13.8018%" y="469" width="0.0179%" height="15" fill="rgb(244,137,37)" fg:x="5394" fg:w="7"/><text x="14.0518%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicU64::load (6 samples, 0.02%)</title><rect x="13.8043%" y="453" width="0.0154%" height="15" fill="rgb(240,136,2)" fg:x="5395" fg:w="6"/><text x="14.0543%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="13.8043%" y="437" width="0.0154%" height="15" fill="rgb(239,18,37)" fg:x="5395" fg:w="6"/><text x="14.0543%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::push (16 samples, 0.04%)</title><rect x="13.8734%" y="453" width="0.0409%" height="15" fill="rgb(218,185,22)" fg:x="5422" fg:w="16"/><text x="14.1234%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push (16 samples, 0.04%)</title><rect x="13.8734%" y="437" width="0.0409%" height="15" fill="rgb(225,218,4)" fg:x="5422" fg:w="16"/><text x="14.1234%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::try_push (16 samples, 0.04%)</title><rect x="13.8734%" y="421" width="0.0409%" height="15" fill="rgb(230,182,32)" fg:x="5422" fg:w="16"/><text x="14.1234%" y="431.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push_unchecked (14 samples, 0.04%)</title><rect x="13.8785%" y="405" width="0.0358%" height="15" fill="rgb(242,56,43)" fg:x="5424" fg:w="14"/><text x="14.1285%" y="415.50"></text></g><g><title>core::ptr::write (12 samples, 0.03%)</title><rect x="13.8836%" y="389" width="0.0307%" height="15" fill="rgb(233,99,24)" fg:x="5426" fg:w="12"/><text x="14.1336%" y="399.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::write (4 samples, 0.01%)</title><rect x="13.9297%" y="453" width="0.0102%" height="15" fill="rgb(234,209,42)" fg:x="5444" fg:w="4"/><text x="14.1797%" y="463.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (51 samples, 0.13%)</title><rect x="13.8197%" y="469" width="0.1305%" height="15" fill="rgb(227,7,12)" fg:x="5401" fg:w="51"/><text x="14.0697%" y="479.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (28 samples, 0.07%)</title><rect x="13.9578%" y="453" width="0.0716%" height="15" fill="rgb(245,203,43)" fg:x="5455" fg:w="28"/><text x="14.2078%" y="463.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (28 samples, 0.07%)</title><rect x="13.9578%" y="437" width="0.0716%" height="15" fill="rgb(238,205,33)" fg:x="5455" fg:w="28"/><text x="14.2078%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (28 samples, 0.07%)</title><rect x="13.9578%" y="421" width="0.0716%" height="15" fill="rgb(231,56,7)" fg:x="5455" fg:w="28"/><text x="14.2078%" y="431.50"></text></g><g><title>zssp::zeta::from_nonce (33 samples, 0.08%)</title><rect x="13.9502%" y="469" width="0.0844%" height="15" fill="rgb(244,186,29)" fg:x="5452" fg:w="33"/><text x="14.2002%" y="479.50"></text></g><g><title>&lt;core::slice::iter::IterMut&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::next (6 samples, 0.02%)</title><rect x="14.0474%" y="453" width="0.0154%" height="15" fill="rgb(234,111,31)" fg:x="5490" fg:w="6"/><text x="14.2974%" y="463.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (76 samples, 0.19%)</title><rect x="14.0627%" y="453" width="0.1945%" height="15" fill="rgb(241,149,10)" fg:x="5496" fg:w="76"/><text x="14.3127%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (76 samples, 0.19%)</title><rect x="14.0627%" y="437" width="0.1945%" height="15" fill="rgb(249,206,44)" fg:x="5496" fg:w="76"/><text x="14.3127%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (75 samples, 0.19%)</title><rect x="14.0653%" y="421" width="0.1919%" height="15" fill="rgb(251,153,30)" fg:x="5497" fg:w="75"/><text x="14.3153%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (75 samples, 0.19%)</title><rect x="14.0653%" y="405" width="0.1919%" height="15" fill="rgb(239,152,38)" fg:x="5497" fg:w="75"/><text x="14.3153%" y="415.50"></text></g><g><title>CRYPTO_gcm128_decrypt (231 samples, 0.59%)</title><rect x="14.6615%" y="357" width="0.5911%" height="15" fill="rgb(249,139,47)" fg:x="5730" fg:w="231"/><text x="14.9115%" y="367.50"></text></g><g><title>[libcrypto.so.3] (86 samples, 0.22%)</title><rect x="15.0325%" y="341" width="0.2201%" height="15" fill="rgb(244,64,35)" fg:x="5875" fg:w="86"/><text x="15.2825%" y="351.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (440 samples, 1.13%)</title><rect x="15.2525%" y="357" width="1.1258%" height="15" fill="rgb(216,46,15)" fg:x="5961" fg:w="440"/><text x="15.5025%" y="367.50"></text></g><g><title>[libcrypto.so.3] (352 samples, 0.90%)</title><rect x="15.4777%" y="341" width="0.9007%" height="15" fill="rgb(250,74,19)" fg:x="6049" fg:w="352"/><text x="15.7277%" y="351.50"></text></g><g><title>[libcrypto.so.3] (27 samples, 0.07%)</title><rect x="16.3093%" y="325" width="0.0691%" height="15" fill="rgb(249,42,33)" fg:x="6374" fg:w="27"/><text x="16.5593%" y="335.50"></text></g><g><title>CRYPTO_gcm128_setiv (23 samples, 0.06%)</title><rect x="16.3784%" y="357" width="0.0589%" height="15" fill="rgb(242,149,17)" fg:x="6401" fg:w="23"/><text x="16.6284%" y="367.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="16.3861%" y="341" width="0.0512%" height="15" fill="rgb(244,29,21)" fg:x="6404" fg:w="20"/><text x="16.6361%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (4,270 samples, 10.93%)</title><rect x="14.2572%" y="453" width="10.9257%" height="15" fill="rgb(220,130,37)" fg:x="5572" fg:w="4270"/><text x="14.5072%" y="463.50">&lt;zssp::crypto_im..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4,270 samples, 10.93%)</title><rect x="14.2572%" y="437" width="10.9257%" height="15" fill="rgb(211,67,2)" fg:x="5572" fg:w="4270"/><text x="14.5072%" y="447.50">zssp::crypto_imp..</text></g><g><title>EVP_DecryptUpdate (4,266 samples, 10.92%)</title><rect x="14.2674%" y="421" width="10.9155%" height="15" fill="rgb(235,68,52)" fg:x="5576" fg:w="4266"/><text x="14.5174%" y="431.50">EVP_DecryptUpdate</text></g><g><title>[libcrypto.so.3] (4,171 samples, 10.67%)</title><rect x="14.5105%" y="405" width="10.6724%" height="15" fill="rgb(246,142,3)" fg:x="5671" fg:w="4171"/><text x="14.7605%" y="415.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,167 samples, 10.66%)</title><rect x="14.5208%" y="389" width="10.6622%" height="15" fill="rgb(241,25,7)" fg:x="5675" fg:w="4167"/><text x="14.7708%" y="399.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,144 samples, 10.60%)</title><rect x="14.5796%" y="373" width="10.6033%" height="15" fill="rgb(242,119,39)" fg:x="5698" fg:w="4144"/><text x="14.8296%" y="383.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,418 samples, 8.75%)</title><rect x="16.4372%" y="357" width="8.7457%" height="15" fill="rgb(241,98,45)" fg:x="6424" fg:w="3418"/><text x="16.6872%" y="367.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,257 samples, 8.33%)</title><rect x="16.8492%" y="341" width="8.3338%" height="15" fill="rgb(254,28,30)" fg:x="6585" fg:w="3257"/><text x="17.0992%" y="351.50">[libcrypto.s..</text></g><g><title>asm_sysvec_reschedule_ipi (17 samples, 0.04%)</title><rect x="25.1395%" y="325" width="0.0435%" height="15" fill="rgb(241,142,54)" fg:x="9825" fg:w="17"/><text x="25.3895%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (16 samples, 0.04%)</title><rect x="25.1420%" y="309" width="0.0409%" height="15" fill="rgb(222,85,15)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="319.50"></text></g><g><title>irqentry_exit (16 samples, 0.04%)</title><rect x="25.1420%" y="293" width="0.0409%" height="15" fill="rgb(210,85,47)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (16 samples, 0.04%)</title><rect x="25.1420%" y="277" width="0.0409%" height="15" fill="rgb(224,206,25)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (16 samples, 0.04%)</title><rect x="25.1420%" y="261" width="0.0409%" height="15" fill="rgb(243,201,19)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (16 samples, 0.04%)</title><rect x="25.1420%" y="245" width="0.0409%" height="15" fill="rgb(236,59,4)" fg:x="9826" fg:w="16"/><text x="25.3920%" y="255.50"></text></g><g><title>schedule (15 samples, 0.04%)</title><rect x="25.1446%" y="229" width="0.0384%" height="15" fill="rgb(254,179,45)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="239.50"></text></g><g><title>__schedule (15 samples, 0.04%)</title><rect x="25.1446%" y="213" width="0.0384%" height="15" fill="rgb(226,14,10)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (15 samples, 0.04%)</title><rect x="25.1446%" y="197" width="0.0384%" height="15" fill="rgb(244,27,41)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (15 samples, 0.04%)</title><rect x="25.1446%" y="181" width="0.0384%" height="15" fill="rgb(235,35,32)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="191.50"></text></g><g><title>perf_ctx_enable (15 samples, 0.04%)</title><rect x="25.1446%" y="165" width="0.0384%" height="15" fill="rgb(218,68,31)" fg:x="9827" fg:w="15"/><text x="25.3946%" y="175.50"></text></g><g><title>CRYPTO_clear_free (92 samples, 0.24%)</title><rect x="25.2392%" y="357" width="0.2354%" height="15" fill="rgb(207,120,37)" fg:x="9864" fg:w="92"/><text x="25.4892%" y="367.50"></text></g><g><title>OPENSSL_cleanse (92 samples, 0.24%)</title><rect x="25.2392%" y="341" width="0.2354%" height="15" fill="rgb(227,98,0)" fg:x="9864" fg:w="92"/><text x="25.4892%" y="351.50"></text></g><g><title>EVP_CIPHER_free (27 samples, 0.07%)</title><rect x="25.4746%" y="357" width="0.0691%" height="15" fill="rgb(207,7,3)" fg:x="9956" fg:w="27"/><text x="25.7246%" y="367.50"></text></g><g><title>cfree (42 samples, 0.11%)</title><rect x="25.5463%" y="357" width="0.1075%" height="15" fill="rgb(206,98,19)" fg:x="9984" fg:w="42"/><text x="25.7963%" y="367.50"></text></g><g><title>[libc.so.6] (7 samples, 0.02%)</title><rect x="25.6358%" y="341" width="0.0179%" height="15" fill="rgb(217,5,26)" fg:x="10019" fg:w="7"/><text x="25.8858%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_free (184 samples, 0.47%)</title><rect x="25.1855%" y="389" width="0.4708%" height="15" fill="rgb(235,190,38)" fg:x="9843" fg:w="184"/><text x="25.4355%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_reset (180 samples, 0.46%)</title><rect x="25.1957%" y="373" width="0.4606%" height="15" fill="rgb(247,86,24)" fg:x="9847" fg:w="180"/><text x="25.4457%" y="383.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec&gt; (210 samples, 0.54%)</title><rect x="25.1829%" y="437" width="0.5373%" height="15" fill="rgb(205,101,16)" fg:x="9842" fg:w="210"/><text x="25.4329%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::CipherCtx&gt; (210 samples, 0.54%)</title><rect x="25.1829%" y="421" width="0.5373%" height="15" fill="rgb(246,168,33)" fg:x="9842" fg:w="210"/><text x="25.4329%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::CipherCtx as core::ops::drop::Drop&gt;::drop (210 samples, 0.54%)</title><rect x="25.1829%" y="405" width="0.5373%" height="15" fill="rgb(231,114,1)" fg:x="9842" fg:w="210"/><text x="25.4329%" y="415.50"></text></g><g><title>cfree (25 samples, 0.06%)</title><rect x="25.6563%" y="389" width="0.0640%" height="15" fill="rgb(207,184,53)" fg:x="10027" fg:w="25"/><text x="25.9063%" y="399.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="25.6819%" y="373" width="0.0384%" height="15" fill="rgb(224,95,51)" fg:x="10037" fg:w="15"/><text x="25.9319%" y="383.50"></text></g><g><title>CRYPTO_gcm128_finish (29 samples, 0.07%)</title><rect x="25.7587%" y="357" width="0.0742%" height="15" fill="rgb(212,188,45)" fg:x="10067" fg:w="29"/><text x="26.0087%" y="367.50"></text></g><g><title>[libcrypto.so.3] (18 samples, 0.05%)</title><rect x="25.7868%" y="341" width="0.0461%" height="15" fill="rgb(223,154,38)" fg:x="10078" fg:w="18"/><text x="26.0368%" y="351.50"></text></g><g><title>[libcrypto.so.3] (33 samples, 0.08%)</title><rect x="25.7510%" y="373" width="0.0844%" height="15" fill="rgb(251,22,52)" fg:x="10064" fg:w="33"/><text x="26.0010%" y="383.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (46 samples, 0.12%)</title><rect x="25.7203%" y="437" width="0.1177%" height="15" fill="rgb(229,209,22)" fg:x="10052" fg:w="46"/><text x="25.9703%" y="447.50"></text></g><g><title>EVP_DecryptFinal_ex (45 samples, 0.12%)</title><rect x="25.7228%" y="421" width="0.1151%" height="15" fill="rgb(234,138,34)" fg:x="10053" fg:w="45"/><text x="25.9728%" y="431.50"></text></g><g><title>[libcrypto.so.3] (38 samples, 0.10%)</title><rect x="25.7408%" y="405" width="0.0972%" height="15" fill="rgb(212,95,11)" fg:x="10060" fg:w="38"/><text x="25.9908%" y="415.50"></text></g><g><title>[libcrypto.so.3] (37 samples, 0.09%)</title><rect x="25.7433%" y="389" width="0.0947%" height="15" fill="rgb(240,179,47)" fg:x="10061" fg:w="37"/><text x="25.9933%" y="399.50"></text></g><g><title>OSSL_PARAM_get_octet_string (6 samples, 0.02%)</title><rect x="25.9429%" y="389" width="0.0154%" height="15" fill="rgb(240,163,11)" fg:x="10139" fg:w="6"/><text x="26.1929%" y="399.50"></text></g><g><title>[libc.so.6] (17 samples, 0.04%)</title><rect x="25.9787%" y="373" width="0.0435%" height="15" fill="rgb(236,37,12)" fg:x="10153" fg:w="17"/><text x="26.2287%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (26 samples, 0.07%)</title><rect x="25.9582%" y="389" width="0.0665%" height="15" fill="rgb(232,164,16)" fg:x="10145" fg:w="26"/><text x="26.2082%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (333 samples, 0.85%)</title><rect x="25.1829%" y="453" width="0.8521%" height="15" fill="rgb(244,205,15)" fg:x="9842" fg:w="333"/><text x="25.4329%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::set_tag (77 samples, 0.20%)</title><rect x="25.8380%" y="437" width="0.1970%" height="15" fill="rgb(223,117,47)" fg:x="10098" fg:w="77"/><text x="26.0880%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (77 samples, 0.20%)</title><rect x="25.8380%" y="421" width="0.1970%" height="15" fill="rgb(244,107,35)" fg:x="10098" fg:w="77"/><text x="26.0880%" y="431.50"></text></g><g><title>[libcrypto.so.3] (39 samples, 0.10%)</title><rect x="25.9352%" y="405" width="0.0998%" height="15" fill="rgb(205,140,8)" fg:x="10136" fg:w="39"/><text x="26.1852%" y="415.50"></text></g><g><title>OSSL_PARAM_locate_const (4 samples, 0.01%)</title><rect x="26.0248%" y="389" width="0.0102%" height="15" fill="rgb(228,84,46)" fg:x="10171" fg:w="4"/><text x="26.2748%" y="399.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="26.1450%" y="389" width="0.0384%" height="15" fill="rgb(254,188,9)" fg:x="10218" fg:w="15"/><text x="26.3950%" y="399.50"></text></g><g><title>OSSL_PARAM_locate (28 samples, 0.07%)</title><rect x="26.1194%" y="405" width="0.0716%" height="15" fill="rgb(206,112,54)" fg:x="10208" fg:w="28"/><text x="26.3694%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (64 samples, 0.16%)</title><rect x="26.0350%" y="437" width="0.1638%" height="15" fill="rgb(216,84,49)" fg:x="10175" fg:w="64"/><text x="26.2850%" y="447.50"></text></g><g><title>[libcrypto.so.3] (42 samples, 0.11%)</title><rect x="26.0913%" y="421" width="0.1075%" height="15" fill="rgb(214,194,35)" fg:x="10197" fg:w="42"/><text x="26.3413%" y="431.50"></text></g><g><title>[libc.so.6] (25 samples, 0.06%)</title><rect x="26.3855%" y="341" width="0.0640%" height="15" fill="rgb(249,28,3)" fg:x="10312" fg:w="25"/><text x="26.6355%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (48 samples, 0.12%)</title><rect x="26.3446%" y="357" width="0.1228%" height="15" fill="rgb(222,56,52)" fg:x="10296" fg:w="48"/><text x="26.5946%" y="367.50"></text></g><g><title>strcmp@plt (7 samples, 0.02%)</title><rect x="26.4495%" y="341" width="0.0179%" height="15" fill="rgb(245,217,50)" fg:x="10337" fg:w="7"/><text x="26.6995%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (81 samples, 0.21%)</title><rect x="26.2678%" y="389" width="0.2073%" height="15" fill="rgb(213,201,24)" fg:x="10266" fg:w="81"/><text x="26.5178%" y="399.50"></text></g><g><title>[libcrypto.so.3] (63 samples, 0.16%)</title><rect x="26.3139%" y="373" width="0.1612%" height="15" fill="rgb(248,116,28)" fg:x="10284" fg:w="63"/><text x="26.5639%" y="383.50"></text></g><g><title>[libc.so.6] (20 samples, 0.05%)</title><rect x="26.5672%" y="341" width="0.0512%" height="15" fill="rgb(219,72,43)" fg:x="10383" fg:w="20"/><text x="26.8172%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (41 samples, 0.10%)</title><rect x="26.5212%" y="357" width="0.1049%" height="15" fill="rgb(209,138,14)" fg:x="10365" fg:w="41"/><text x="26.7712%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_key_length (60 samples, 0.15%)</title><rect x="26.4751%" y="389" width="0.1535%" height="15" fill="rgb(222,18,33)" fg:x="10347" fg:w="60"/><text x="26.7251%" y="399.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="26.4930%" y="373" width="0.1356%" height="15" fill="rgb(213,199,7)" fg:x="10354" fg:w="53"/><text x="26.7430%" y="383.50"></text></g><g><title>pthread_rwlock_rdlock (159 samples, 0.41%)</title><rect x="26.6747%" y="325" width="0.4068%" height="15" fill="rgb(250,110,10)" fg:x="10425" fg:w="159"/><text x="26.9247%" y="335.50"></text></g><g><title>CRYPTO_THREAD_read_lock (163 samples, 0.42%)</title><rect x="26.6696%" y="341" width="0.4171%" height="15" fill="rgb(248,123,6)" fg:x="10423" fg:w="163"/><text x="26.9196%" y="351.50"></text></g><g><title>pthread_rwlock_unlock (79 samples, 0.20%)</title><rect x="27.0994%" y="325" width="0.2021%" height="15" fill="rgb(206,91,31)" fg:x="10591" fg:w="79"/><text x="27.3494%" y="335.50"></text></g><g><title>CRYPTO_THREAD_unlock (86 samples, 0.22%)</title><rect x="27.0943%" y="341" width="0.2201%" height="15" fill="rgb(211,154,13)" fg:x="10589" fg:w="86"/><text x="27.3443%" y="351.50"></text></g><g><title>pthread_rwlock_unlock@plt (5 samples, 0.01%)</title><rect x="27.3016%" y="325" width="0.0128%" height="15" fill="rgb(225,148,7)" fg:x="10670" fg:w="5"/><text x="27.5516%" y="335.50"></text></g><g><title>EVP_CIPHER_up_ref (42 samples, 0.11%)</title><rect x="27.3195%" y="341" width="0.1075%" height="15" fill="rgb(220,160,43)" fg:x="10677" fg:w="42"/><text x="27.5695%" y="351.50"></text></g><g><title>OPENSSL_LH_retrieve (70 samples, 0.18%)</title><rect x="27.4269%" y="341" width="0.1791%" height="15" fill="rgb(213,52,39)" fg:x="10719" fg:w="70"/><text x="27.6769%" y="351.50"></text></g><g><title>[libcrypto.so.3] (57 samples, 0.15%)</title><rect x="27.4602%" y="325" width="0.1458%" height="15" fill="rgb(243,137,7)" fg:x="10732" fg:w="57"/><text x="27.7102%" y="335.50"></text></g><g><title>[libcrypto.so.3] (6 samples, 0.02%)</title><rect x="27.5907%" y="309" width="0.0154%" height="15" fill="rgb(230,79,13)" fg:x="10783" fg:w="6"/><text x="27.8407%" y="319.50"></text></g><g><title>pthread_rwlock_rdlock (43 samples, 0.11%)</title><rect x="27.6240%" y="309" width="0.1100%" height="15" fill="rgb(247,105,23)" fg:x="10796" fg:w="43"/><text x="27.8740%" y="319.50"></text></g><g><title>CRYPTO_THREAD_read_lock (47 samples, 0.12%)</title><rect x="27.6189%" y="325" width="0.1203%" height="15" fill="rgb(223,179,41)" fg:x="10794" fg:w="47"/><text x="27.8689%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (66 samples, 0.17%)</title><rect x="27.7391%" y="309" width="0.1689%" height="15" fill="rgb(218,9,34)" fg:x="10841" fg:w="66"/><text x="27.9891%" y="319.50"></text></g><g><title>CRYPTO_THREAD_unlock (69 samples, 0.18%)</title><rect x="27.7391%" y="325" width="0.1766%" height="15" fill="rgb(222,106,8)" fg:x="10841" fg:w="69"/><text x="27.9891%" y="335.50"></text></g><g><title>CRYPTO_strndup (13 samples, 0.03%)</title><rect x="27.9157%" y="325" width="0.0333%" height="15" fill="rgb(211,220,0)" fg:x="10910" fg:w="13"/><text x="28.1657%" y="335.50"></text></g><g><title>OPENSSL_strcasecmp (38 samples, 0.10%)</title><rect x="28.1741%" y="293" width="0.0972%" height="15" fill="rgb(229,52,16)" fg:x="11011" fg:w="38"/><text x="28.4241%" y="303.50"></text></g><g><title>OPENSSL_LH_retrieve (162 samples, 0.41%)</title><rect x="27.9489%" y="325" width="0.4145%" height="15" fill="rgb(212,155,18)" fg:x="10923" fg:w="162"/><text x="28.1989%" y="335.50"></text></g><g><title>[libcrypto.so.3] (151 samples, 0.39%)</title><rect x="27.9771%" y="309" width="0.3864%" height="15" fill="rgb(242,21,14)" fg:x="10934" fg:w="151"/><text x="28.2271%" y="319.50"></text></g><g><title>[libcrypto.so.3] (36 samples, 0.09%)</title><rect x="28.2713%" y="293" width="0.0921%" height="15" fill="rgb(222,19,48)" fg:x="11049" fg:w="36"/><text x="28.5213%" y="303.50"></text></g><g><title>cfree (12 samples, 0.03%)</title><rect x="28.3686%" y="325" width="0.0307%" height="15" fill="rgb(232,45,27)" fg:x="11087" fg:w="12"/><text x="28.6186%" y="335.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="28.3890%" y="309" width="0.0102%" height="15" fill="rgb(249,103,42)" fg:x="11095" fg:w="4"/><text x="28.6390%" y="319.50"></text></g><g><title>[libcrypto.so.3] (310 samples, 0.79%)</title><rect x="27.6086%" y="341" width="0.7932%" height="15" fill="rgb(246,81,33)" fg:x="10790" fg:w="310"/><text x="27.8586%" y="351.50"></text></g><g><title>pthread_getspecific (7 samples, 0.02%)</title><rect x="28.4018%" y="341" width="0.0179%" height="15" fill="rgb(252,33,42)" fg:x="11100" fg:w="7"/><text x="28.6518%" y="351.50"></text></g><g><title>EVP_CIPHER_fetch (702 samples, 1.80%)</title><rect x="26.6286%" y="389" width="1.7962%" height="15" fill="rgb(209,212,41)" fg:x="10407" fg:w="702"/><text x="26.8786%" y="399.50">E..</text></g><g><title>[libcrypto.so.3] (699 samples, 1.79%)</title><rect x="26.6363%" y="373" width="1.7885%" height="15" fill="rgb(207,154,6)" fg:x="10410" fg:w="699"/><text x="26.8863%" y="383.50">[..</text></g><g><title>[libcrypto.so.3] (690 samples, 1.77%)</title><rect x="26.6593%" y="357" width="1.7655%" height="15" fill="rgb(223,64,47)" fg:x="10419" fg:w="690"/><text x="26.9093%" y="367.50"></text></g><g><title>EVP_CIPHER_free (18 samples, 0.05%)</title><rect x="28.4249%" y="389" width="0.0461%" height="15" fill="rgb(211,161,38)" fg:x="11109" fg:w="18"/><text x="28.6749%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (27 samples, 0.07%)</title><rect x="28.4709%" y="389" width="0.0691%" height="15" fill="rgb(219,138,40)" fg:x="11127" fg:w="27"/><text x="28.7209%" y="399.50"></text></g><g><title>[libc.so.6] (10 samples, 0.03%)</title><rect x="28.5707%" y="357" width="0.0256%" height="15" fill="rgb(241,228,46)" fg:x="11166" fg:w="10"/><text x="28.8207%" y="367.50"></text></g><g><title>malloc (9 samples, 0.02%)</title><rect x="28.5963%" y="357" width="0.0230%" height="15" fill="rgb(223,209,38)" fg:x="11176" fg:w="9"/><text x="28.8463%" y="367.50"></text></g><g><title>CRYPTO_zalloc (22 samples, 0.06%)</title><rect x="28.5656%" y="373" width="0.0563%" height="15" fill="rgb(236,164,45)" fg:x="11164" fg:w="22"/><text x="28.8156%" y="383.50"></text></g><g><title>OPENSSL_init_crypto (4 samples, 0.01%)</title><rect x="28.6219%" y="373" width="0.0102%" height="15" fill="rgb(231,15,5)" fg:x="11186" fg:w="4"/><text x="28.8719%" y="383.50"></text></g><g><title>CRYPTO_gcm128_init (155 samples, 0.40%)</title><rect x="28.6398%" y="357" width="0.3966%" height="15" fill="rgb(252,35,15)" fg:x="11193" fg:w="155"/><text x="28.8898%" y="367.50"></text></g><g><title>[libcrypto.so.3] (126 samples, 0.32%)</title><rect x="28.7140%" y="341" width="0.3224%" height="15" fill="rgb(248,181,18)" fg:x="11222" fg:w="126"/><text x="28.9640%" y="351.50"></text></g><g><title>[libcrypto.so.3] (188 samples, 0.48%)</title><rect x="28.6372%" y="373" width="0.4810%" height="15" fill="rgb(233,39,42)" fg:x="11192" fg:w="188"/><text x="28.8872%" y="383.50"></text></g><g><title>[libcrypto.so.3] (32 samples, 0.08%)</title><rect x="29.0364%" y="357" width="0.0819%" height="15" fill="rgb(238,110,33)" fg:x="11348" fg:w="32"/><text x="29.2864%" y="367.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (1,141 samples, 2.92%)</title><rect x="26.2013%" y="437" width="2.9195%" height="15" fill="rgb(233,195,10)" fg:x="10240" fg:w="1141"/><text x="26.4513%" y="447.50">zs..</text></g><g><title>EVP_CipherInit_ex (1,141 samples, 2.92%)</title><rect x="26.2013%" y="421" width="2.9195%" height="15" fill="rgb(254,105,3)" fg:x="10240" fg:w="1141"/><text x="26.4513%" y="431.50">EV..</text></g><g><title>[libcrypto.so.3] (1,141 samples, 2.92%)</title><rect x="26.2013%" y="405" width="2.9195%" height="15" fill="rgb(221,225,9)" fg:x="10240" fg:w="1141"/><text x="26.4513%" y="415.50">[l..</text></g><g><title>[libcrypto.so.3] (224 samples, 0.57%)</title><rect x="28.5477%" y="389" width="0.5732%" height="15" fill="rgb(224,227,45)" fg:x="11157" fg:w="224"/><text x="28.7977%" y="399.50"></text></g><g><title>malloc (12 samples, 0.03%)</title><rect x="29.1311%" y="405" width="0.0307%" height="15" fill="rgb(229,198,43)" fg:x="11385" fg:w="12"/><text x="29.3811%" y="415.50"></text></g><g><title>CRYPTO_zalloc (17 samples, 0.04%)</title><rect x="29.1208%" y="421" width="0.0435%" height="15" fill="rgb(206,209,35)" fg:x="11381" fg:w="17"/><text x="29.3708%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (1,226 samples, 3.14%)</title><rect x="26.0350%" y="453" width="3.1370%" height="15" fill="rgb(245,195,53)" fg:x="10175" fg:w="1226"/><text x="26.2850%" y="463.50">&lt;zs..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::new (20 samples, 0.05%)</title><rect x="29.1208%" y="437" width="0.0512%" height="15" fill="rgb(240,92,26)" fg:x="11381" fg:w="20"/><text x="29.3708%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::Index&lt;I&gt; for [T]&gt;::index (6 samples, 0.02%)</title><rect x="29.1797%" y="453" width="0.0154%" height="15" fill="rgb(207,40,23)" fg:x="11404" fg:w="6"/><text x="29.4297%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index (6 samples, 0.02%)</title><rect x="29.1797%" y="437" width="0.0154%" height="15" fill="rgb(223,111,35)" fg:x="11404" fg:w="6"/><text x="29.4297%" y="447.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (5 samples, 0.01%)</title><rect x="29.1822%" y="421" width="0.0128%" height="15" fill="rgb(229,147,28)" fg:x="11405" fg:w="5"/><text x="29.4322%" y="431.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (5 samples, 0.01%)</title><rect x="29.1822%" y="405" width="0.0128%" height="15" fill="rgb(211,29,28)" fg:x="11405" fg:w="5"/><text x="29.4322%" y="415.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::add (4 samples, 0.01%)</title><rect x="29.1848%" y="389" width="0.0102%" height="15" fill="rgb(228,72,33)" fg:x="11406" fg:w="4"/><text x="29.4348%" y="399.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::offset (4 samples, 0.01%)</title><rect x="29.1848%" y="373" width="0.0102%" height="15" fill="rgb(205,214,31)" fg:x="11406" fg:w="4"/><text x="29.4348%" y="383.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (4 samples, 0.01%)</title><rect x="29.1950%" y="437" width="0.0102%" height="15" fill="rgb(224,111,15)" fg:x="11410" fg:w="4"/><text x="29.4450%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (5 samples, 0.01%)</title><rect x="29.1950%" y="453" width="0.0128%" height="15" fill="rgb(253,21,26)" fg:x="11410" fg:w="5"/><text x="29.4450%" y="463.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (232 samples, 0.59%)</title><rect x="29.2078%" y="453" width="0.5936%" height="15" fill="rgb(245,139,43)" fg:x="11415" fg:w="232"/><text x="29.4578%" y="463.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (232 samples, 0.59%)</title><rect x="29.2078%" y="437" width="0.5936%" height="15" fill="rgb(252,170,7)" fg:x="11415" fg:w="232"/><text x="29.4578%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (230 samples, 0.59%)</title><rect x="29.2129%" y="421" width="0.5885%" height="15" fill="rgb(231,118,14)" fg:x="11417" fg:w="230"/><text x="29.4629%" y="431.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (228 samples, 0.58%)</title><rect x="29.2181%" y="405" width="0.5834%" height="15" fill="rgb(238,83,0)" fg:x="11419" fg:w="228"/><text x="29.4681%" y="415.50"></text></g><g><title>[libc.so.6] (227 samples, 0.58%)</title><rect x="29.2206%" y="389" width="0.5808%" height="15" fill="rgb(221,39,39)" fg:x="11420" fg:w="227"/><text x="29.4706%" y="399.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::update (27 samples, 0.07%)</title><rect x="29.8014%" y="453" width="0.0691%" height="15" fill="rgb(222,119,46)" fg:x="11647" fg:w="27"/><text x="30.0514%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_max (26 samples, 0.07%)</title><rect x="29.8040%" y="437" width="0.0665%" height="15" fill="rgb(222,165,49)" fg:x="11648" fg:w="26"/><text x="30.0540%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_umax (26 samples, 0.07%)</title><rect x="29.8040%" y="421" width="0.0665%" height="15" fill="rgb(219,113,52)" fg:x="11648" fg:w="26"/><text x="30.0540%" y="431.50"></text></g><g><title>zssp::zeta::receive_payload_in_place (6,190 samples, 15.84%)</title><rect x="14.0346%" y="469" width="15.8385%" height="15" fill="rgb(214,7,15)" fg:x="5485" fg:w="6190"/><text x="14.2846%" y="479.50">zssp::zeta::receive_payl..</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8,570 samples, 21.93%)</title><rect x="8.1112%" y="485" width="21.9283%" height="15" fill="rgb(235,32,4)" fg:x="3170" fg:w="8570"/><text x="8.3612%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::receive</text></g><g><title>zssp::zssp::parse_fragment_header (65 samples, 0.17%)</title><rect x="29.8731%" y="469" width="0.1663%" height="15" fill="rgb(238,90,54)" fg:x="11675" fg:w="65"/><text x="30.1231%" y="479.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (4 samples, 0.01%)</title><rect x="30.0292%" y="453" width="0.0102%" height="15" fill="rgb(213,208,19)" fg:x="11736" fg:w="4"/><text x="30.2792%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (4 samples, 0.01%)</title><rect x="30.0292%" y="437" width="0.0102%" height="15" fill="rgb(233,156,4)" fg:x="11736" fg:w="4"/><text x="30.2792%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (56 samples, 0.14%)</title><rect x="30.1162%" y="437" width="0.1433%" height="15" fill="rgb(207,194,5)" fg:x="11770" fg:w="56"/><text x="30.3662%" y="447.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (56 samples, 0.14%)</title><rect x="30.1162%" y="421" width="0.1433%" height="15" fill="rgb(206,111,30)" fg:x="11770" fg:w="56"/><text x="30.3662%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (55 samples, 0.14%)</title><rect x="30.1187%" y="405" width="0.1407%" height="15" fill="rgb(243,70,54)" fg:x="11771" fg:w="55"/><text x="30.3687%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (52 samples, 0.13%)</title><rect x="30.1264%" y="389" width="0.1331%" height="15" fill="rgb(242,28,8)" fg:x="11774" fg:w="52"/><text x="30.3764%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_swap (52 samples, 0.13%)</title><rect x="30.1264%" y="373" width="0.1331%" height="15" fill="rgb(219,106,18)" fg:x="11774" fg:w="52"/><text x="30.3764%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (64 samples, 0.16%)</title><rect x="30.2595%" y="437" width="0.1638%" height="15" fill="rgb(244,222,10)" fg:x="11826" fg:w="64"/><text x="30.5095%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (61 samples, 0.16%)</title><rect x="30.2671%" y="421" width="0.1561%" height="15" fill="rgb(236,179,52)" fg:x="11829" fg:w="61"/><text x="30.5171%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (55 samples, 0.14%)</title><rect x="30.2825%" y="405" width="0.1407%" height="15" fill="rgb(213,23,39)" fg:x="11835" fg:w="55"/><text x="30.5325%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (55 samples, 0.14%)</title><rect x="30.2825%" y="389" width="0.1407%" height="15" fill="rgb(238,48,10)" fg:x="11835" fg:w="55"/><text x="30.5325%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (314 samples, 0.80%)</title><rect x="30.1008%" y="453" width="0.8034%" height="15" fill="rgb(251,196,23)" fg:x="11764" fg:w="314"/><text x="30.3508%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (188 samples, 0.48%)</title><rect x="30.4232%" y="437" width="0.4810%" height="15" fill="rgb(250,152,24)" fg:x="11890" fg:w="188"/><text x="30.6732%" y="447.50"></text></g><g><title>EVP_EncryptUpdate (183 samples, 0.47%)</title><rect x="30.4360%" y="421" width="0.4682%" height="15" fill="rgb(209,150,17)" fg:x="11895" fg:w="183"/><text x="30.6860%" y="431.50"></text></g><g><title>[libcrypto.so.3] (148 samples, 0.38%)</title><rect x="30.5256%" y="405" width="0.3787%" height="15" fill="rgb(234,202,34)" fg:x="11930" fg:w="148"/><text x="30.7756%" y="415.50"></text></g><g><title>[libcrypto.so.3] (106 samples, 0.27%)</title><rect x="30.6330%" y="389" width="0.2712%" height="15" fill="rgb(253,148,53)" fg:x="11972" fg:w="106"/><text x="30.8830%" y="399.50"></text></g><g><title>[libcrypto.so.3] (96 samples, 0.25%)</title><rect x="30.6586%" y="373" width="0.2456%" height="15" fill="rgb(218,129,16)" fg:x="11982" fg:w="96"/><text x="30.9086%" y="383.50"></text></g><g><title>CRYPTO_gcm128_encrypt (250 samples, 0.64%)</title><rect x="31.2139%" y="357" width="0.6397%" height="15" fill="rgb(216,85,19)" fg:x="12199" fg:w="250"/><text x="31.4639%" y="367.50"></text></g><g><title>[libcrypto.so.3] (143 samples, 0.37%)</title><rect x="31.4876%" y="341" width="0.3659%" height="15" fill="rgb(235,228,7)" fg:x="12306" fg:w="143"/><text x="31.7376%" y="351.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (415 samples, 1.06%)</title><rect x="31.8535%" y="357" width="1.0619%" height="15" fill="rgb(245,175,0)" fg:x="12449" fg:w="415"/><text x="32.1035%" y="367.50"></text></g><g><title>[libcrypto.so.3] (319 samples, 0.82%)</title><rect x="32.0992%" y="341" width="0.8162%" height="15" fill="rgb(208,168,36)" fg:x="12545" fg:w="319"/><text x="32.3492%" y="351.50"></text></g><g><title>[libcrypto.so.3] (28 samples, 0.07%)</title><rect x="32.8438%" y="325" width="0.0716%" height="15" fill="rgb(246,171,24)" fg:x="12836" fg:w="28"/><text x="33.0938%" y="335.50"></text></g><g><title>[libcrypto.so.3] (19 samples, 0.05%)</title><rect x="32.9180%" y="341" width="0.0486%" height="15" fill="rgb(215,142,24)" fg:x="12865" fg:w="19"/><text x="33.1680%" y="351.50"></text></g><g><title>CRYPTO_gcm128_setiv (25 samples, 0.06%)</title><rect x="32.9154%" y="357" width="0.0640%" height="15" fill="rgb(250,187,7)" fg:x="12864" fg:w="25"/><text x="33.1654%" y="367.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="32.9666%" y="341" width="0.0128%" height="15" fill="rgb(228,66,33)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="32.9666%" y="325" width="0.0128%" height="15" fill="rgb(234,215,21)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="335.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="32.9666%" y="309" width="0.0128%" height="15" fill="rgb(222,191,20)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="32.9666%" y="293" width="0.0128%" height="15" fill="rgb(245,79,54)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="32.9666%" y="277" width="0.0128%" height="15" fill="rgb(240,10,37)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="32.9666%" y="261" width="0.0128%" height="15" fill="rgb(214,192,32)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="32.9666%" y="245" width="0.0128%" height="15" fill="rgb(209,36,54)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="32.9666%" y="229" width="0.0128%" height="15" fill="rgb(220,10,11)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="239.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="32.9666%" y="213" width="0.0128%" height="15" fill="rgb(221,106,17)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="32.9666%" y="197" width="0.0128%" height="15" fill="rgb(251,142,44)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="207.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="32.9666%" y="181" width="0.0128%" height="15" fill="rgb(238,13,15)" fg:x="12884" fg:w="5"/><text x="33.2166%" y="191.50"></text></g><g><title>perf_ctx_enable (18 samples, 0.05%)</title><rect x="39.3429%" y="165" width="0.0461%" height="15" fill="rgb(208,107,27)" fg:x="15376" fg:w="18"/><text x="39.5929%" y="175.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (3,317 samples, 8.49%)</title><rect x="30.9043%" y="453" width="8.4873%" height="15" fill="rgb(205,136,37)" fg:x="12078" fg:w="3317"/><text x="31.1543%" y="463.50">&lt;zssp::crypt..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (3,311 samples, 8.47%)</title><rect x="30.9196%" y="437" width="8.4719%" height="15" fill="rgb(250,205,27)" fg:x="12084" fg:w="3311"/><text x="31.1696%" y="447.50">zssp::crypto..</text></g><g><title>EVP_EncryptUpdate (3,309 samples, 8.47%)</title><rect x="30.9247%" y="421" width="8.4668%" height="15" fill="rgb(210,80,43)" fg:x="12086" fg:w="3309"/><text x="31.1747%" y="431.50">EVP_EncryptU..</text></g><g><title>[libcrypto.so.3] (3,257 samples, 8.33%)</title><rect x="31.0578%" y="405" width="8.3338%" height="15" fill="rgb(247,160,36)" fg:x="12138" fg:w="3257"/><text x="31.3078%" y="415.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,255 samples, 8.33%)</title><rect x="31.0629%" y="389" width="8.3286%" height="15" fill="rgb(234,13,49)" fg:x="12140" fg:w="3255"/><text x="31.3129%" y="399.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,235 samples, 8.28%)</title><rect x="31.1141%" y="373" width="8.2775%" height="15" fill="rgb(234,122,0)" fg:x="12160" fg:w="3235"/><text x="31.3641%" y="383.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (2,506 samples, 6.41%)</title><rect x="32.9794%" y="357" width="6.4122%" height="15" fill="rgb(207,146,38)" fg:x="12889" fg:w="2506"/><text x="33.2294%" y="367.50">[libcryp..</text></g><g><title>[libcrypto.so.3] (2,299 samples, 5.88%)</title><rect x="33.5090%" y="341" width="5.8825%" height="15" fill="rgb(207,177,25)" fg:x="13096" fg:w="2299"/><text x="33.7590%" y="351.50">[libcry..</text></g><g><title>asm_sysvec_reschedule_ipi (20 samples, 0.05%)</title><rect x="39.3404%" y="325" width="0.0512%" height="15" fill="rgb(211,178,42)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (20 samples, 0.05%)</title><rect x="39.3404%" y="309" width="0.0512%" height="15" fill="rgb(230,69,54)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="319.50"></text></g><g><title>irqentry_exit (20 samples, 0.05%)</title><rect x="39.3404%" y="293" width="0.0512%" height="15" fill="rgb(214,135,41)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (20 samples, 0.05%)</title><rect x="39.3404%" y="277" width="0.0512%" height="15" fill="rgb(237,67,25)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (20 samples, 0.05%)</title><rect x="39.3404%" y="261" width="0.0512%" height="15" fill="rgb(222,189,50)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (20 samples, 0.05%)</title><rect x="39.3404%" y="245" width="0.0512%" height="15" fill="rgb(245,148,34)" fg:x="15375" fg:w="20"/><text x="39.5904%" y="255.50"></text></g><g><title>schedule (19 samples, 0.05%)</title><rect x="39.3429%" y="229" width="0.0486%" height="15" fill="rgb(222,29,6)" fg:x="15376" fg:w="19"/><text x="39.5929%" y="239.50"></text></g><g><title>__schedule (19 samples, 0.05%)</title><rect x="39.3429%" y="213" width="0.0486%" height="15" fill="rgb(221,189,43)" fg:x="15376" fg:w="19"/><text x="39.5929%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (19 samples, 0.05%)</title><rect x="39.3429%" y="197" width="0.0486%" height="15" fill="rgb(207,36,27)" fg:x="15376" fg:w="19"/><text x="39.5929%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (19 samples, 0.05%)</title><rect x="39.3429%" y="181" width="0.0486%" height="15" fill="rgb(217,90,24)" fg:x="15376" fg:w="19"/><text x="39.5929%" y="191.50"></text></g><g><title>CRYPTO_clear_free (107 samples, 0.27%)</title><rect x="39.4402%" y="357" width="0.2738%" height="15" fill="rgb(224,66,35)" fg:x="15414" fg:w="107"/><text x="39.6902%" y="367.50"></text></g><g><title>OPENSSL_cleanse (103 samples, 0.26%)</title><rect x="39.4504%" y="341" width="0.2635%" height="15" fill="rgb(221,13,50)" fg:x="15418" fg:w="103"/><text x="39.7004%" y="351.50"></text></g><g><title>EVP_CIPHER_free (30 samples, 0.08%)</title><rect x="39.7139%" y="357" width="0.0768%" height="15" fill="rgb(236,68,49)" fg:x="15521" fg:w="30"/><text x="39.9639%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_free (206 samples, 0.53%)</title><rect x="39.3967%" y="389" width="0.5271%" height="15" fill="rgb(229,146,28)" fg:x="15397" fg:w="206"/><text x="39.6467%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_reset (205 samples, 0.52%)</title><rect x="39.3992%" y="373" width="0.5245%" height="15" fill="rgb(225,31,38)" fg:x="15398" fg:w="205"/><text x="39.6492%" y="383.50"></text></g><g><title>cfree (52 samples, 0.13%)</title><rect x="39.7907%" y="357" width="0.1331%" height="15" fill="rgb(250,208,3)" fg:x="15551" fg:w="52"/><text x="40.0407%" y="367.50"></text></g><g><title>[libc.so.6] (11 samples, 0.03%)</title><rect x="39.8956%" y="341" width="0.0281%" height="15" fill="rgb(246,54,23)" fg:x="15592" fg:w="11"/><text x="40.1456%" y="351.50"></text></g><g><title>cfree (11 samples, 0.03%)</title><rect x="39.9238%" y="389" width="0.0281%" height="15" fill="rgb(243,76,11)" fg:x="15603" fg:w="11"/><text x="40.1738%" y="399.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="39.9391%" y="373" width="0.0128%" height="15" fill="rgb(245,21,50)" fg:x="15609" fg:w="5"/><text x="40.1891%" y="383.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc&gt; (220 samples, 0.56%)</title><rect x="39.3915%" y="437" width="0.5629%" height="15" fill="rgb(228,9,43)" fg:x="15395" fg:w="220"/><text x="39.6415%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::CipherCtx&gt; (220 samples, 0.56%)</title><rect x="39.3915%" y="421" width="0.5629%" height="15" fill="rgb(208,100,47)" fg:x="15395" fg:w="220"/><text x="39.6415%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::CipherCtx as core::ops::drop::Drop&gt;::drop (220 samples, 0.56%)</title><rect x="39.3915%" y="405" width="0.5629%" height="15" fill="rgb(232,26,8)" fg:x="15395" fg:w="220"/><text x="39.6415%" y="415.50"></text></g><g><title>[libcrypto.so.3] (15 samples, 0.04%)</title><rect x="40.0338%" y="325" width="0.0384%" height="15" fill="rgb(216,166,38)" fg:x="15646" fg:w="15"/><text x="40.2838%" y="335.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (47 samples, 0.12%)</title><rect x="39.9545%" y="437" width="0.1203%" height="15" fill="rgb(251,202,51)" fg:x="15615" fg:w="47"/><text x="40.2045%" y="447.50"></text></g><g><title>EVP_EncryptFinal_ex (46 samples, 0.12%)</title><rect x="39.9570%" y="421" width="0.1177%" height="15" fill="rgb(254,216,34)" fg:x="15616" fg:w="46"/><text x="40.2070%" y="431.50"></text></g><g><title>[libcrypto.so.3] (33 samples, 0.08%)</title><rect x="39.9903%" y="405" width="0.0844%" height="15" fill="rgb(251,32,27)" fg:x="15629" fg:w="33"/><text x="40.2403%" y="415.50"></text></g><g><title>[libcrypto.so.3] (33 samples, 0.08%)</title><rect x="39.9903%" y="389" width="0.0844%" height="15" fill="rgb(208,127,28)" fg:x="15629" fg:w="33"/><text x="40.2403%" y="399.50"></text></g><g><title>[libcrypto.so.3] (29 samples, 0.07%)</title><rect x="40.0005%" y="373" width="0.0742%" height="15" fill="rgb(224,137,22)" fg:x="15633" fg:w="29"/><text x="40.2505%" y="383.50"></text></g><g><title>CRYPTO_gcm128_tag (29 samples, 0.07%)</title><rect x="40.0005%" y="357" width="0.0742%" height="15" fill="rgb(254,70,32)" fg:x="15633" fg:w="29"/><text x="40.2505%" y="367.50"></text></g><g><title>CRYPTO_gcm128_finish (22 samples, 0.06%)</title><rect x="40.0184%" y="341" width="0.0563%" height="15" fill="rgb(229,75,37)" fg:x="15640" fg:w="22"/><text x="40.2684%" y="351.50"></text></g><g><title>[libc.so.6] (32 samples, 0.08%)</title><rect x="40.2001%" y="373" width="0.0819%" height="15" fill="rgb(252,64,23)" fg:x="15711" fg:w="32"/><text x="40.4501%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (53 samples, 0.14%)</title><rect x="40.1592%" y="389" width="0.1356%" height="15" fill="rgb(232,162,48)" fg:x="15695" fg:w="53"/><text x="40.4092%" y="399.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="40.2820%" y="373" width="0.0128%" height="15" fill="rgb(246,160,12)" fg:x="15743" fg:w="5"/><text x="40.5320%" y="383.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::finish (358 samples, 0.92%)</title><rect x="39.3915%" y="453" width="0.9160%" height="15" fill="rgb(247,166,0)" fg:x="15395" fg:w="358"/><text x="39.6415%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::get_tag (91 samples, 0.23%)</title><rect x="40.0747%" y="437" width="0.2328%" height="15" fill="rgb(249,219,21)" fg:x="15662" fg:w="91"/><text x="40.3247%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (91 samples, 0.23%)</title><rect x="40.0747%" y="421" width="0.2328%" height="15" fill="rgb(205,209,3)" fg:x="15662" fg:w="91"/><text x="40.3247%" y="431.50"></text></g><g><title>[libcrypto.so.3] (68 samples, 0.17%)</title><rect x="40.1336%" y="405" width="0.1740%" height="15" fill="rgb(243,44,1)" fg:x="15685" fg:w="68"/><text x="40.3836%" y="415.50"></text></g><g><title>OSSL_PARAM_set_octet_string (5 samples, 0.01%)</title><rect x="40.2948%" y="389" width="0.0128%" height="15" fill="rgb(206,159,16)" fg:x="15748" fg:w="5"/><text x="40.5448%" y="399.50"></text></g><g><title>[libc.so.6] (12 samples, 0.03%)</title><rect x="40.4355%" y="389" width="0.0307%" height="15" fill="rgb(244,77,30)" fg:x="15803" fg:w="12"/><text x="40.6855%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (64 samples, 0.16%)</title><rect x="40.3127%" y="437" width="0.1638%" height="15" fill="rgb(218,69,12)" fg:x="15755" fg:w="64"/><text x="40.5627%" y="447.50"></text></g><g><title>[libcrypto.so.3] (38 samples, 0.10%)</title><rect x="40.3792%" y="421" width="0.0972%" height="15" fill="rgb(212,87,7)" fg:x="15781" fg:w="38"/><text x="40.6292%" y="431.50"></text></g><g><title>OSSL_PARAM_locate (32 samples, 0.08%)</title><rect x="40.3946%" y="405" width="0.0819%" height="15" fill="rgb(245,114,25)" fg:x="15787" fg:w="32"/><text x="40.6446%" y="415.50"></text></g><g><title>strcmp@plt (4 samples, 0.01%)</title><rect x="40.4662%" y="389" width="0.0102%" height="15" fill="rgb(210,61,42)" fg:x="15815" fg:w="4"/><text x="40.7162%" y="399.50"></text></g><g><title>[libc.so.6] (17 samples, 0.04%)</title><rect x="40.6786%" y="341" width="0.0435%" height="15" fill="rgb(211,52,33)" fg:x="15898" fg:w="17"/><text x="40.9286%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (40 samples, 0.10%)</title><rect x="40.6325%" y="357" width="0.1023%" height="15" fill="rgb(234,58,33)" fg:x="15880" fg:w="40"/><text x="40.8825%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="40.7221%" y="341" width="0.0128%" height="15" fill="rgb(220,115,36)" fg:x="15915" fg:w="5"/><text x="40.9721%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (79 samples, 0.20%)</title><rect x="40.5353%" y="389" width="0.2021%" height="15" fill="rgb(243,153,54)" fg:x="15842" fg:w="79"/><text x="40.7853%" y="399.50"></text></g><g><title>[libcrypto.so.3] (55 samples, 0.14%)</title><rect x="40.5967%" y="373" width="0.1407%" height="15" fill="rgb(251,47,18)" fg:x="15866" fg:w="55"/><text x="40.8467%" y="383.50"></text></g><g><title>[libc.so.6] (20 samples, 0.05%)</title><rect x="40.8347%" y="341" width="0.0512%" height="15" fill="rgb(242,102,42)" fg:x="15959" fg:w="20"/><text x="41.0847%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (37 samples, 0.09%)</title><rect x="40.7988%" y="357" width="0.0947%" height="15" fill="rgb(234,31,38)" fg:x="15945" fg:w="37"/><text x="41.0488%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_key_length (63 samples, 0.16%)</title><rect x="40.7374%" y="389" width="0.1612%" height="15" fill="rgb(221,117,51)" fg:x="15921" fg:w="63"/><text x="40.9874%" y="399.50"></text></g><g><title>[libcrypto.so.3] (54 samples, 0.14%)</title><rect x="40.7605%" y="373" width="0.1382%" height="15" fill="rgb(212,20,18)" fg:x="15930" fg:w="54"/><text x="41.0105%" y="383.50"></text></g><g><title>pthread_rwlock_rdlock (130 samples, 0.33%)</title><rect x="40.9498%" y="325" width="0.3326%" height="15" fill="rgb(245,133,36)" fg:x="16004" fg:w="130"/><text x="41.1998%" y="335.50"></text></g><g><title>CRYPTO_THREAD_read_lock (136 samples, 0.35%)</title><rect x="40.9421%" y="341" width="0.3480%" height="15" fill="rgb(212,6,19)" fg:x="16001" fg:w="136"/><text x="41.1921%" y="351.50"></text></g><g><title>pthread_rwlock_unlock (73 samples, 0.19%)</title><rect x="41.3003%" y="325" width="0.1868%" height="15" fill="rgb(218,1,36)" fg:x="16141" fg:w="73"/><text x="41.5503%" y="335.50"></text></g><g><title>CRYPTO_THREAD_unlock (82 samples, 0.21%)</title><rect x="41.2901%" y="341" width="0.2098%" height="15" fill="rgb(246,84,54)" fg:x="16137" fg:w="82"/><text x="41.5401%" y="351.50"></text></g><g><title>pthread_rwlock_unlock@plt (5 samples, 0.01%)</title><rect x="41.4871%" y="325" width="0.0128%" height="15" fill="rgb(242,110,6)" fg:x="16214" fg:w="5"/><text x="41.7371%" y="335.50"></text></g><g><title>EVP_CIPHER_up_ref (24 samples, 0.06%)</title><rect x="41.5050%" y="341" width="0.0614%" height="15" fill="rgb(214,47,5)" fg:x="16221" fg:w="24"/><text x="41.7550%" y="351.50"></text></g><g><title>OPENSSL_LH_retrieve (75 samples, 0.19%)</title><rect x="41.5665%" y="341" width="0.1919%" height="15" fill="rgb(218,159,25)" fg:x="16245" fg:w="75"/><text x="41.8165%" y="351.50"></text></g><g><title>[libcrypto.so.3] (56 samples, 0.14%)</title><rect x="41.6151%" y="325" width="0.1433%" height="15" fill="rgb(215,211,28)" fg:x="16264" fg:w="56"/><text x="41.8651%" y="335.50"></text></g><g><title>[libcrypto.so.3] (5 samples, 0.01%)</title><rect x="41.7456%" y="309" width="0.0128%" height="15" fill="rgb(238,59,32)" fg:x="16315" fg:w="5"/><text x="41.9956%" y="319.50"></text></g><g><title>pthread_rwlock_rdlock (38 samples, 0.10%)</title><rect x="41.7839%" y="309" width="0.0972%" height="15" fill="rgb(226,82,3)" fg:x="16330" fg:w="38"/><text x="42.0339%" y="319.50"></text></g><g><title>CRYPTO_THREAD_read_lock (40 samples, 0.10%)</title><rect x="41.7839%" y="325" width="0.1023%" height="15" fill="rgb(240,164,32)" fg:x="16330" fg:w="40"/><text x="42.0339%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (43 samples, 0.11%)</title><rect x="41.8914%" y="309" width="0.1100%" height="15" fill="rgb(232,46,7)" fg:x="16372" fg:w="43"/><text x="42.1414%" y="319.50"></text></g><g><title>CRYPTO_THREAD_unlock (45 samples, 0.12%)</title><rect x="41.8914%" y="325" width="0.1151%" height="15" fill="rgb(229,129,53)" fg:x="16372" fg:w="45"/><text x="42.1414%" y="335.50"></text></g><g><title>OPENSSL_strnlen (5 samples, 0.01%)</title><rect x="42.0168%" y="309" width="0.0128%" height="15" fill="rgb(234,188,29)" fg:x="16421" fg:w="5"/><text x="42.2668%" y="319.50"></text></g><g><title>CRYPTO_strndup (10 samples, 0.03%)</title><rect x="42.0168%" y="325" width="0.0256%" height="15" fill="rgb(246,141,4)" fg:x="16421" fg:w="10"/><text x="42.2668%" y="335.50"></text></g><g><title>malloc (5 samples, 0.01%)</title><rect x="42.0296%" y="309" width="0.0128%" height="15" fill="rgb(229,23,39)" fg:x="16426" fg:w="5"/><text x="42.2796%" y="319.50"></text></g><g><title>OPENSSL_strcasecmp (41 samples, 0.10%)</title><rect x="42.2010%" y="293" width="0.1049%" height="15" fill="rgb(206,12,3)" fg:x="16493" fg:w="41"/><text x="42.4510%" y="303.50"></text></g><g><title>OPENSSL_LH_retrieve (132 samples, 0.34%)</title><rect x="42.0424%" y="325" width="0.3378%" height="15" fill="rgb(252,226,20)" fg:x="16431" fg:w="132"/><text x="42.2924%" y="335.50"></text></g><g><title>[libcrypto.so.3] (118 samples, 0.30%)</title><rect x="42.0782%" y="309" width="0.3019%" height="15" fill="rgb(216,123,35)" fg:x="16445" fg:w="118"/><text x="42.3282%" y="319.50"></text></g><g><title>[libcrypto.so.3] (29 samples, 0.07%)</title><rect x="42.3059%" y="293" width="0.0742%" height="15" fill="rgb(212,68,40)" fg:x="16534" fg:w="29"/><text x="42.5559%" y="303.50"></text></g><g><title>cfree (19 samples, 0.05%)</title><rect x="42.3801%" y="325" width="0.0486%" height="15" fill="rgb(254,125,32)" fg:x="16563" fg:w="19"/><text x="42.6301%" y="335.50"></text></g><g><title>[libc.so.6] (7 samples, 0.02%)</title><rect x="42.4108%" y="309" width="0.0179%" height="15" fill="rgb(253,97,22)" fg:x="16575" fg:w="7"/><text x="42.6608%" y="319.50"></text></g><g><title>[libcrypto.so.3] (264 samples, 0.68%)</title><rect x="41.7584%" y="341" width="0.6755%" height="15" fill="rgb(241,101,14)" fg:x="16320" fg:w="264"/><text x="42.0084%" y="351.50"></text></g><g><title>EVP_CIPHER_fetch (603 samples, 1.54%)</title><rect x="40.8986%" y="389" width="1.5429%" height="15" fill="rgb(238,103,29)" fg:x="15984" fg:w="603"/><text x="41.1486%" y="399.50"></text></g><g><title>[libcrypto.so.3] (600 samples, 1.54%)</title><rect x="40.9063%" y="373" width="1.5352%" height="15" fill="rgb(233,195,47)" fg:x="15987" fg:w="600"/><text x="41.1563%" y="383.50"></text></g><g><title>[libcrypto.so.3] (594 samples, 1.52%)</title><rect x="40.9217%" y="357" width="1.5199%" height="15" fill="rgb(246,218,30)" fg:x="15993" fg:w="594"/><text x="41.1717%" y="367.50"></text></g><g><title>EVP_CIPHER_free (17 samples, 0.04%)</title><rect x="42.4415%" y="389" width="0.0435%" height="15" fill="rgb(219,145,47)" fg:x="16587" fg:w="17"/><text x="42.6915%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (20 samples, 0.05%)</title><rect x="42.4850%" y="389" width="0.0512%" height="15" fill="rgb(243,12,26)" fg:x="16604" fg:w="20"/><text x="42.7350%" y="399.50"></text></g><g><title>OBJ_nid2sn (6 samples, 0.02%)</title><rect x="42.5362%" y="389" width="0.0154%" height="15" fill="rgb(214,87,16)" fg:x="16624" fg:w="6"/><text x="42.7862%" y="399.50"></text></g><g><title>malloc (8 samples, 0.02%)</title><rect x="42.5874%" y="357" width="0.0205%" height="15" fill="rgb(208,99,42)" fg:x="16644" fg:w="8"/><text x="42.8374%" y="367.50"></text></g><g><title>CRYPTO_zalloc (14 samples, 0.04%)</title><rect x="42.5771%" y="373" width="0.0358%" height="15" fill="rgb(253,99,2)" fg:x="16640" fg:w="14"/><text x="42.8271%" y="383.50"></text></g><g><title>OPENSSL_init_crypto (5 samples, 0.01%)</title><rect x="42.6130%" y="373" width="0.0128%" height="15" fill="rgb(220,168,23)" fg:x="16654" fg:w="5"/><text x="42.8630%" y="383.50"></text></g><g><title>CRYPTO_gcm128_init (161 samples, 0.41%)</title><rect x="42.6309%" y="357" width="0.4120%" height="15" fill="rgb(242,38,24)" fg:x="16661" fg:w="161"/><text x="42.8809%" y="367.50"></text></g><g><title>[libcrypto.so.3] (132 samples, 0.34%)</title><rect x="42.7051%" y="341" width="0.3378%" height="15" fill="rgb(225,182,9)" fg:x="16690" fg:w="132"/><text x="42.9551%" y="351.50"></text></g><g><title>[libcrypto.so.3] (201 samples, 0.51%)</title><rect x="42.6283%" y="373" width="0.5143%" height="15" fill="rgb(243,178,37)" fg:x="16660" fg:w="201"/><text x="42.8783%" y="383.50"></text></g><g><title>[libcrypto.so.3] (39 samples, 0.10%)</title><rect x="43.0428%" y="357" width="0.0998%" height="15" fill="rgb(232,139,19)" fg:x="16822" fg:w="39"/><text x="43.2928%" y="367.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (1,042 samples, 2.67%)</title><rect x="40.4790%" y="437" width="2.6662%" height="15" fill="rgb(225,201,24)" fg:x="15820" fg:w="1042"/><text x="40.7290%" y="447.50">zs..</text></g><g><title>EVP_CipherInit_ex (1,042 samples, 2.67%)</title><rect x="40.4790%" y="421" width="2.6662%" height="15" fill="rgb(221,47,46)" fg:x="15820" fg:w="1042"/><text x="40.7290%" y="431.50">EV..</text></g><g><title>[libcrypto.so.3] (1,042 samples, 2.67%)</title><rect x="40.4790%" y="405" width="2.6662%" height="15" fill="rgb(249,23,13)" fg:x="15820" fg:w="1042"/><text x="40.7290%" y="415.50">[l..</text></g><g><title>[libcrypto.so.3] (232 samples, 0.59%)</title><rect x="42.5516%" y="389" width="0.5936%" height="15" fill="rgb(219,9,5)" fg:x="16630" fg:w="232"/><text x="42.8016%" y="399.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="43.1477%" y="405" width="0.0102%" height="15" fill="rgb(254,171,16)" fg:x="16863" fg:w="4"/><text x="43.3977%" y="415.50"></text></g><g><title>malloc (9 samples, 0.02%)</title><rect x="43.1580%" y="405" width="0.0230%" height="15" fill="rgb(230,171,20)" fg:x="16867" fg:w="9"/><text x="43.4080%" y="415.50"></text></g><g><title>CRYPTO_zalloc (15 samples, 0.04%)</title><rect x="43.1452%" y="421" width="0.0384%" height="15" fill="rgb(210,71,41)" fg:x="16862" fg:w="15"/><text x="43.3952%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (1,125 samples, 2.88%)</title><rect x="40.3076%" y="453" width="2.8786%" height="15" fill="rgb(206,173,20)" fg:x="15753" fg:w="1125"/><text x="40.5576%" y="463.50">&lt;z..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::new (16 samples, 0.04%)</title><rect x="43.1452%" y="437" width="0.0409%" height="15" fill="rgb(233,88,34)" fg:x="16862" fg:w="16"/><text x="43.3952%" y="447.50"></text></g><g><title>__rdl_alloc (9 samples, 0.02%)</title><rect x="43.1912%" y="277" width="0.0230%" height="15" fill="rgb(223,209,46)" fg:x="16880" fg:w="9"/><text x="43.4412%" y="287.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::alloc (9 samples, 0.02%)</title><rect x="43.1912%" y="261" width="0.0230%" height="15" fill="rgb(250,43,18)" fg:x="16880" fg:w="9"/><text x="43.4412%" y="271.50"></text></g><g><title>[libc.so.6] (54 samples, 0.14%)</title><rect x="47.1240%" y="245" width="0.1382%" height="15" fill="rgb(208,13,10)" fg:x="18417" fg:w="54"/><text x="47.3740%" y="255.50"></text></g><g><title>[libc.so.6] (925 samples, 2.37%)</title><rect x="44.8979%" y="261" width="2.3668%" height="15" fill="rgb(212,200,36)" fg:x="17547" fg:w="925"/><text x="45.1479%" y="271.50">[l..</text></g><g><title>__entry_text_start (4 samples, 0.01%)</title><rect x="47.3057%" y="245" width="0.0102%" height="15" fill="rgb(225,90,30)" fg:x="18488" fg:w="4"/><text x="47.5557%" y="255.50"></text></g><g><title>__get_user_nocheck_4 (5 samples, 0.01%)</title><rect x="47.3338%" y="149" width="0.0128%" height="15" fill="rgb(236,182,39)" fg:x="18499" fg:w="5"/><text x="47.5838%" y="159.50"></text></g><g><title>futex_q_lock (5 samples, 0.01%)</title><rect x="47.3517%" y="149" width="0.0128%" height="15" fill="rgb(212,144,35)" fg:x="18506" fg:w="5"/><text x="47.6017%" y="159.50"></text></g><g><title>futex_q_unlock (6 samples, 0.02%)</title><rect x="47.3645%" y="149" width="0.0154%" height="15" fill="rgb(228,63,44)" fg:x="18511" fg:w="6"/><text x="47.6145%" y="159.50"></text></g><g><title>futex_wait (24 samples, 0.06%)</title><rect x="47.3210%" y="181" width="0.0614%" height="15" fill="rgb(228,109,6)" fg:x="18494" fg:w="24"/><text x="47.5710%" y="191.50"></text></g><g><title>futex_wait_setup (19 samples, 0.05%)</title><rect x="47.3338%" y="165" width="0.0486%" height="15" fill="rgb(238,117,24)" fg:x="18499" fg:w="19"/><text x="47.5838%" y="175.50"></text></g><g><title>__x64_sys_futex (26 samples, 0.07%)</title><rect x="47.3185%" y="213" width="0.0665%" height="15" fill="rgb(242,26,26)" fg:x="18493" fg:w="26"/><text x="47.5685%" y="223.50"></text></g><g><title>do_futex (26 samples, 0.07%)</title><rect x="47.3185%" y="197" width="0.0665%" height="15" fill="rgb(221,92,48)" fg:x="18493" fg:w="26"/><text x="47.5685%" y="207.50"></text></g><g><title>do_syscall_64 (31 samples, 0.08%)</title><rect x="47.3185%" y="229" width="0.0793%" height="15" fill="rgb(209,209,32)" fg:x="18493" fg:w="31"/><text x="47.5685%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (4 samples, 0.01%)</title><rect x="47.3875%" y="213" width="0.0102%" height="15" fill="rgb(221,70,22)" fg:x="18520" fg:w="4"/><text x="47.6375%" y="223.50"></text></g><g><title>__lll_lock_wait_private (53 samples, 0.14%)</title><rect x="47.2647%" y="261" width="0.1356%" height="15" fill="rgb(248,145,5)" fg:x="18472" fg:w="53"/><text x="47.5147%" y="271.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (33 samples, 0.08%)</title><rect x="47.3159%" y="245" width="0.0844%" height="15" fill="rgb(226,116,26)" fg:x="18492" fg:w="33"/><text x="47.5659%" y="255.50"></text></g><g><title>__entry_text_start (4 samples, 0.01%)</title><rect x="47.4157%" y="245" width="0.0102%" height="15" fill="rgb(244,5,17)" fg:x="18531" fg:w="4"/><text x="47.6657%" y="255.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="47.4310%" y="181" width="0.0102%" height="15" fill="rgb(252,159,33)" fg:x="18537" fg:w="4"/><text x="47.6810%" y="191.50"></text></g><g><title>futex_hash (4 samples, 0.01%)</title><rect x="47.4413%" y="181" width="0.0102%" height="15" fill="rgb(206,71,0)" fg:x="18541" fg:w="4"/><text x="47.6913%" y="191.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="47.5385%" y="165" width="0.0102%" height="15" fill="rgb(233,118,54)" fg:x="18579" fg:w="4"/><text x="47.7885%" y="175.50"></text></g><g><title>native_queued_spin_lock_slowpath (4 samples, 0.01%)</title><rect x="47.5385%" y="149" width="0.0102%" height="15" fill="rgb(234,83,48)" fg:x="18579" fg:w="4"/><text x="47.7885%" y="159.50"></text></g><g><title>futex_wake_mark (13 samples, 0.03%)</title><rect x="47.5487%" y="165" width="0.0333%" height="15" fill="rgb(228,3,54)" fg:x="18583" fg:w="13"/><text x="47.7987%" y="175.50"></text></g><g><title>preempt_schedule_thunk (5 samples, 0.01%)</title><rect x="47.6716%" y="133" width="0.0128%" height="15" fill="rgb(226,155,13)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="143.50"></text></g><g><title>preempt_schedule (5 samples, 0.01%)</title><rect x="47.6716%" y="117" width="0.0128%" height="15" fill="rgb(241,28,37)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="127.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="47.6716%" y="101" width="0.0128%" height="15" fill="rgb(233,93,10)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="111.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="47.6716%" y="85" width="0.0128%" height="15" fill="rgb(225,113,19)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="95.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="47.6716%" y="69" width="0.0128%" height="15" fill="rgb(241,2,18)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="79.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="47.6716%" y="53" width="0.0128%" height="15" fill="rgb(228,207,21)" fg:x="18631" fg:w="5"/><text x="47.9216%" y="63.50"></text></g><g><title>__smp_call_single_queue (12 samples, 0.03%)</title><rect x="47.6997%" y="117" width="0.0307%" height="15" fill="rgb(213,211,35)" fg:x="18642" fg:w="12"/><text x="47.9497%" y="127.50"></text></g><g><title>native_send_call_func_single_ipi (9 samples, 0.02%)</title><rect x="47.7074%" y="101" width="0.0230%" height="15" fill="rgb(209,83,10)" fg:x="18645" fg:w="9"/><text x="47.9574%" y="111.50"></text></g><g><title>x2apic_send_IPI (9 samples, 0.02%)</title><rect x="47.7074%" y="85" width="0.0230%" height="15" fill="rgb(209,164,1)" fg:x="18645" fg:w="9"/><text x="47.9574%" y="95.50"></text></g><g><title>native_write_msr (6 samples, 0.02%)</title><rect x="47.7151%" y="69" width="0.0154%" height="15" fill="rgb(213,184,43)" fg:x="18648" fg:w="6"/><text x="47.9651%" y="79.50"></text></g><g><title>llist_add_batch (17 samples, 0.04%)</title><rect x="47.7304%" y="117" width="0.0435%" height="15" fill="rgb(231,61,34)" fg:x="18654" fg:w="17"/><text x="47.9804%" y="127.50"></text></g><g><title>do_futex (136 samples, 0.35%)</title><rect x="47.4310%" y="197" width="0.3480%" height="15" fill="rgb(235,75,3)" fg:x="18537" fg:w="136"/><text x="47.6810%" y="207.50"></text></g><g><title>futex_wake (128 samples, 0.33%)</title><rect x="47.4515%" y="181" width="0.3275%" height="15" fill="rgb(220,106,47)" fg:x="18545" fg:w="128"/><text x="47.7015%" y="191.50"></text></g><g><title>wake_up_q (75 samples, 0.19%)</title><rect x="47.5871%" y="165" width="0.1919%" height="15" fill="rgb(210,196,33)" fg:x="18598" fg:w="75"/><text x="47.8371%" y="175.50"></text></g><g><title>try_to_wake_up (66 samples, 0.17%)</title><rect x="47.6102%" y="149" width="0.1689%" height="15" fill="rgb(229,154,42)" fg:x="18607" fg:w="66"/><text x="47.8602%" y="159.50"></text></g><g><title>ttwu_queue_wakelist (36 samples, 0.09%)</title><rect x="47.6869%" y="133" width="0.0921%" height="15" fill="rgb(228,114,26)" fg:x="18637" fg:w="36"/><text x="47.9369%" y="143.50"></text></g><g><title>__x64_sys_futex (137 samples, 0.35%)</title><rect x="47.4310%" y="213" width="0.3505%" height="15" fill="rgb(208,144,1)" fg:x="18537" fg:w="137"/><text x="47.6810%" y="223.50"></text></g><g><title>do_syscall_64 (141 samples, 0.36%)</title><rect x="47.4310%" y="229" width="0.3608%" height="15" fill="rgb(239,112,37)" fg:x="18537" fg:w="141"/><text x="47.6810%" y="239.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (144 samples, 0.37%)</title><rect x="47.4259%" y="245" width="0.3685%" height="15" fill="rgb(210,96,50)" fg:x="18535" fg:w="144"/><text x="47.6759%" y="255.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (1,803 samples, 4.61%)</title><rect x="43.1861%" y="373" width="4.6134%" height="15" fill="rgb(222,178,2)" fg:x="16878" fg:w="1803"/><text x="43.4361%" y="383.50">alloc..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (1,803 samples, 4.61%)</title><rect x="43.1861%" y="357" width="4.6134%" height="15" fill="rgb(226,74,18)" fg:x="16878" fg:w="1803"/><text x="43.4361%" y="367.50">alloc..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (1,803 samples, 4.61%)</title><rect x="43.1861%" y="341" width="4.6134%" height="15" fill="rgb(225,67,54)" fg:x="16878" fg:w="1803"/><text x="43.4361%" y="351.50">alloc..</text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (1,801 samples, 4.61%)</title><rect x="43.1912%" y="325" width="4.6083%" height="15" fill="rgb(251,92,32)" fg:x="16880" fg:w="1801"/><text x="43.4412%" y="335.50">&lt;allo..</text></g><g><title>alloc::alloc::Global::alloc_impl (1,801 samples, 4.61%)</title><rect x="43.1912%" y="309" width="4.6083%" height="15" fill="rgb(228,149,22)" fg:x="16880" fg:w="1801"/><text x="43.4412%" y="319.50">alloc..</text></g><g><title>alloc::alloc::alloc (1,801 samples, 4.61%)</title><rect x="43.1912%" y="293" width="4.6083%" height="15" fill="rgb(243,54,13)" fg:x="16880" fg:w="1801"/><text x="43.4412%" y="303.50">alloc..</text></g><g><title>malloc (1,789 samples, 4.58%)</title><rect x="43.2219%" y="277" width="4.5776%" height="15" fill="rgb(243,180,28)" fg:x="16892" fg:w="1789"/><text x="43.4719%" y="287.50">malloc</text></g><g><title>__lll_lock_wake_private (156 samples, 0.40%)</title><rect x="47.4003%" y="261" width="0.3992%" height="15" fill="rgb(208,167,24)" fg:x="18525" fg:w="156"/><text x="47.6503%" y="271.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (2,000 samples, 5.12%)</title><rect x="43.1861%" y="437" width="5.1174%" height="15" fill="rgb(245,73,45)" fg:x="16878" fg:w="2000"/><text x="43.4361%" y="447.50">alloc:..</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (2,000 samples, 5.12%)</title><rect x="43.1861%" y="421" width="5.1174%" height="15" fill="rgb(237,203,48)" fg:x="16878" fg:w="2000"/><text x="43.4361%" y="431.50">alloc:..</text></g><g><title>alloc::slice::hack::to_vec (2,000 samples, 5.12%)</title><rect x="43.1861%" y="405" width="5.1174%" height="15" fill="rgb(211,197,16)" fg:x="16878" fg:w="2000"/><text x="43.4361%" y="415.50">alloc:..</text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (2,000 samples, 5.12%)</title><rect x="43.1861%" y="389" width="5.1174%" height="15" fill="rgb(243,99,51)" fg:x="16878" fg:w="2000"/><text x="43.4361%" y="399.50">&lt;T as ..</text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (197 samples, 0.50%)</title><rect x="47.7995%" y="373" width="0.5041%" height="15" fill="rgb(215,123,29)" fg:x="18681" fg:w="197"/><text x="48.0495%" y="383.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (197 samples, 0.50%)</title><rect x="47.7995%" y="357" width="0.5041%" height="15" fill="rgb(239,186,37)" fg:x="18681" fg:w="197"/><text x="48.0495%" y="367.50"></text></g><g><title>[libc.so.6] (194 samples, 0.50%)</title><rect x="47.8072%" y="341" width="0.4964%" height="15" fill="rgb(252,136,39)" fg:x="18684" fg:w="194"/><text x="48.0572%" y="351.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::is_ok (4 samples, 0.01%)</title><rect x="48.3036%" y="437" width="0.0102%" height="15" fill="rgb(223,213,32)" fg:x="18878" fg:w="4"/><text x="48.5536%" y="447.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (4 samples, 0.01%)</title><rect x="51.4303%" y="389" width="0.0102%" height="15" fill="rgb(233,115,5)" fg:x="20100" fg:w="4"/><text x="51.6803%" y="399.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (4 samples, 0.01%)</title><rect x="51.4406%" y="389" width="0.0102%" height="15" fill="rgb(207,226,44)" fg:x="20104" fg:w="4"/><text x="51.6906%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (66 samples, 0.17%)</title><rect x="51.5148%" y="373" width="0.1689%" height="15" fill="rgb(208,126,0)" fg:x="20133" fg:w="66"/><text x="51.7648%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (66 samples, 0.17%)</title><rect x="51.5148%" y="357" width="0.1689%" height="15" fill="rgb(244,66,21)" fg:x="20133" fg:w="66"/><text x="51.7648%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (102 samples, 0.26%)</title><rect x="51.4508%" y="389" width="0.2610%" height="15" fill="rgb(222,97,12)" fg:x="20108" fg:w="102"/><text x="51.7008%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (11 samples, 0.03%)</title><rect x="51.6836%" y="373" width="0.0281%" height="15" fill="rgb(219,213,19)" fg:x="20199" fg:w="11"/><text x="51.9336%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (11 samples, 0.03%)</title><rect x="51.6836%" y="357" width="0.0281%" height="15" fill="rgb(252,169,30)" fg:x="20199" fg:w="11"/><text x="51.9336%" y="367.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (6 samples, 0.02%)</title><rect x="51.7476%" y="357" width="0.0154%" height="15" fill="rgb(206,32,51)" fg:x="20224" fg:w="6"/><text x="51.9976%" y="367.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="51.7502%" y="341" width="0.0128%" height="15" fill="rgb(250,172,42)" fg:x="20225" fg:w="5"/><text x="52.0002%" y="351.50"></text></g><g><title>futex_wake_mark (8 samples, 0.02%)</title><rect x="51.8448%" y="149" width="0.0205%" height="15" fill="rgb(209,34,43)" fg:x="20262" fg:w="8"/><text x="52.0948%" y="159.50"></text></g><g><title>__smp_call_single_queue (7 samples, 0.02%)</title><rect x="51.9446%" y="101" width="0.0179%" height="15" fill="rgb(223,11,35)" fg:x="20301" fg:w="7"/><text x="52.1946%" y="111.50"></text></g><g><title>native_send_call_func_single_ipi (6 samples, 0.02%)</title><rect x="51.9472%" y="85" width="0.0154%" height="15" fill="rgb(251,219,26)" fg:x="20302" fg:w="6"/><text x="52.1972%" y="95.50"></text></g><g><title>x2apic_send_IPI (6 samples, 0.02%)</title><rect x="51.9472%" y="69" width="0.0154%" height="15" fill="rgb(231,119,3)" fg:x="20302" fg:w="6"/><text x="52.1972%" y="79.50"></text></g><g><title>native_write_msr (4 samples, 0.01%)</title><rect x="51.9523%" y="53" width="0.0102%" height="15" fill="rgb(216,97,11)" fg:x="20304" fg:w="4"/><text x="52.2023%" y="63.50"></text></g><g><title>llist_add_batch (7 samples, 0.02%)</title><rect x="51.9625%" y="101" width="0.0179%" height="15" fill="rgb(223,59,9)" fg:x="20308" fg:w="7"/><text x="52.2125%" y="111.50"></text></g><g><title>futex_wake (71 samples, 0.18%)</title><rect x="51.8013%" y="165" width="0.1817%" height="15" fill="rgb(233,93,31)" fg:x="20245" fg:w="71"/><text x="52.0513%" y="175.50"></text></g><g><title>wake_up_q (44 samples, 0.11%)</title><rect x="51.8704%" y="149" width="0.1126%" height="15" fill="rgb(239,81,33)" fg:x="20272" fg:w="44"/><text x="52.1204%" y="159.50"></text></g><g><title>try_to_wake_up (43 samples, 0.11%)</title><rect x="51.8730%" y="133" width="0.1100%" height="15" fill="rgb(213,120,34)" fg:x="20273" fg:w="43"/><text x="52.1230%" y="143.50"></text></g><g><title>ttwu_queue_wakelist (24 samples, 0.06%)</title><rect x="51.9216%" y="117" width="0.0614%" height="15" fill="rgb(243,49,53)" fg:x="20292" fg:w="24"/><text x="52.1716%" y="127.50"></text></g><g><title>__x64_sys_futex (75 samples, 0.19%)</title><rect x="51.7937%" y="197" width="0.1919%" height="15" fill="rgb(247,216,33)" fg:x="20242" fg:w="75"/><text x="52.0437%" y="207.50"></text></g><g><title>do_futex (75 samples, 0.19%)</title><rect x="51.7937%" y="181" width="0.1919%" height="15" fill="rgb(226,26,14)" fg:x="20242" fg:w="75"/><text x="52.0437%" y="191.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (76 samples, 0.19%)</title><rect x="51.7937%" y="229" width="0.1945%" height="15" fill="rgb(215,49,53)" fg:x="20242" fg:w="76"/><text x="52.0437%" y="239.50"></text></g><g><title>do_syscall_64 (76 samples, 0.19%)</title><rect x="51.7937%" y="213" width="0.1945%" height="15" fill="rgb(245,162,40)" fg:x="20242" fg:w="76"/><text x="52.0437%" y="223.50"></text></g><g><title>&lt;core::slice::iter::Iter&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::position (88 samples, 0.23%)</title><rect x="51.7655%" y="341" width="0.2252%" height="15" fill="rgb(229,68,17)" fg:x="20231" fg:w="88"/><text x="52.0155%" y="351.50"></text></g><g><title>std::sync::mpmc::waker::Waker::try_select::_{{closure}} (88 samples, 0.23%)</title><rect x="51.7655%" y="325" width="0.2252%" height="15" fill="rgb(213,182,10)" fg:x="20231" fg:w="88"/><text x="52.0155%" y="335.50"></text></g><g><title>std::sync::mpmc::context::Context::unpark (84 samples, 0.21%)</title><rect x="51.7758%" y="309" width="0.2149%" height="15" fill="rgb(245,125,30)" fg:x="20235" fg:w="84"/><text x="52.0258%" y="319.50"></text></g><g><title>std::thread::Thread::unpark (84 samples, 0.21%)</title><rect x="51.7758%" y="293" width="0.2149%" height="15" fill="rgb(232,202,2)" fg:x="20235" fg:w="84"/><text x="52.0258%" y="303.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::unpark (84 samples, 0.21%)</title><rect x="51.7758%" y="277" width="0.2149%" height="15" fill="rgb(237,140,51)" fg:x="20235" fg:w="84"/><text x="52.0258%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wake (81 samples, 0.21%)</title><rect x="51.7834%" y="261" width="0.2073%" height="15" fill="rgb(236,157,25)" fg:x="20238" fg:w="81"/><text x="52.0334%" y="271.50"></text></g><g><title>syscall (80 samples, 0.20%)</title><rect x="51.7860%" y="245" width="0.2047%" height="15" fill="rgb(219,209,0)" fg:x="20239" fg:w="80"/><text x="52.0360%" y="255.50"></text></g><g><title>std::sync::mpmc::waker::Waker::try_select (89 samples, 0.23%)</title><rect x="51.7655%" y="357" width="0.2277%" height="15" fill="rgb(240,116,54)" fg:x="20231" fg:w="89"/><text x="52.0155%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (112 samples, 0.29%)</title><rect x="51.7118%" y="389" width="0.2866%" height="15" fill="rgb(216,10,36)" fg:x="20210" fg:w="112"/><text x="51.9618%" y="399.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (105 samples, 0.27%)</title><rect x="51.7297%" y="373" width="0.2687%" height="15" fill="rgb(222,72,44)" fg:x="20217" fg:w="105"/><text x="51.9797%" y="383.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="51.9984%" y="101" width="0.0128%" height="15" fill="rgb(232,159,9)" fg:x="20322" fg:w="5"/><text x="52.2484%" y="111.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="51.9984%" y="85" width="0.0128%" height="15" fill="rgb(210,39,32)" fg:x="20322" fg:w="5"/><text x="52.2484%" y="95.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="51.9984%" y="69" width="0.0128%" height="15" fill="rgb(216,194,45)" fg:x="20322" fg:w="5"/><text x="52.2484%" y="79.50"></text></g><g><title>futex_wait_queue (6 samples, 0.02%)</title><rect x="51.9984%" y="149" width="0.0154%" height="15" fill="rgb(218,18,35)" fg:x="20322" fg:w="6"/><text x="52.2484%" y="159.50"></text></g><g><title>schedule (6 samples, 0.02%)</title><rect x="51.9984%" y="133" width="0.0154%" height="15" fill="rgb(207,83,51)" fg:x="20322" fg:w="6"/><text x="52.2484%" y="143.50"></text></g><g><title>__schedule (6 samples, 0.02%)</title><rect x="51.9984%" y="117" width="0.0154%" height="15" fill="rgb(225,63,43)" fg:x="20322" fg:w="6"/><text x="52.2484%" y="127.50"></text></g><g><title>std::sync::mpmc::context::Context::wait_until (7 samples, 0.02%)</title><rect x="51.9984%" y="309" width="0.0179%" height="15" fill="rgb(207,57,36)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="319.50"></text></g><g><title>std::thread::park (7 samples, 0.02%)</title><rect x="51.9984%" y="293" width="0.0179%" height="15" fill="rgb(216,99,33)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="303.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::park (7 samples, 0.02%)</title><rect x="51.9984%" y="277" width="0.0179%" height="15" fill="rgb(225,42,16)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wait (7 samples, 0.02%)</title><rect x="51.9984%" y="261" width="0.0179%" height="15" fill="rgb(220,201,45)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="271.50"></text></g><g><title>syscall (7 samples, 0.02%)</title><rect x="51.9984%" y="245" width="0.0179%" height="15" fill="rgb(225,33,4)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="255.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (7 samples, 0.02%)</title><rect x="51.9984%" y="229" width="0.0179%" height="15" fill="rgb(224,33,50)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="239.50"></text></g><g><title>do_syscall_64 (7 samples, 0.02%)</title><rect x="51.9984%" y="213" width="0.0179%" height="15" fill="rgb(246,198,51)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="223.50"></text></g><g><title>__x64_sys_futex (7 samples, 0.02%)</title><rect x="51.9984%" y="197" width="0.0179%" height="15" fill="rgb(205,22,4)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="207.50"></text></g><g><title>do_futex (7 samples, 0.02%)</title><rect x="51.9984%" y="181" width="0.0179%" height="15" fill="rgb(206,3,8)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="191.50"></text></g><g><title>futex_wait (7 samples, 0.02%)</title><rect x="51.9984%" y="165" width="0.0179%" height="15" fill="rgb(251,23,15)" fg:x="20322" fg:w="7"/><text x="52.2484%" y="175.50"></text></g><g><title>std::sync::mpmc::context::Context::with (8 samples, 0.02%)</title><rect x="51.9984%" y="389" width="0.0205%" height="15" fill="rgb(252,88,28)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="399.50"></text></g><g><title>std::thread::local::LocalKey&lt;T&gt;::try_with (8 samples, 0.02%)</title><rect x="51.9984%" y="373" width="0.0205%" height="15" fill="rgb(212,127,14)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="383.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (8 samples, 0.02%)</title><rect x="51.9984%" y="357" width="0.0205%" height="15" fill="rgb(247,145,37)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="367.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (8 samples, 0.02%)</title><rect x="51.9984%" y="341" width="0.0205%" height="15" fill="rgb(209,117,53)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="351.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send::_{{closure}} (8 samples, 0.02%)</title><rect x="51.9984%" y="325" width="0.0205%" height="15" fill="rgb(212,90,42)" fg:x="20322" fg:w="8"/><text x="52.2484%" y="335.50"></text></g><g><title>core::hint::spin_loop (14 samples, 0.04%)</title><rect x="52.0188%" y="373" width="0.0358%" height="15" fill="rgb(218,164,37)" fg:x="20330" fg:w="14"/><text x="52.2688%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_pause (14 samples, 0.04%)</title><rect x="52.0188%" y="357" width="0.0358%" height="15" fill="rgb(246,65,34)" fg:x="20330" fg:w="14"/><text x="52.2688%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (251 samples, 0.64%)</title><rect x="51.4150%" y="405" width="0.6422%" height="15" fill="rgb(231,100,33)" fg:x="20094" fg:w="251"/><text x="51.6650%" y="415.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::spin_light (15 samples, 0.04%)</title><rect x="52.0188%" y="389" width="0.0384%" height="15" fill="rgb(228,126,14)" fg:x="20330" fg:w="15"/><text x="52.2688%" y="399.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (3,468 samples, 8.87%)</title><rect x="43.1861%" y="453" width="8.8737%" height="15" fill="rgb(215,173,21)" fg:x="16878" fg:w="3468"/><text x="43.4361%" y="463.50">benchmark::bo..</text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (1,464 samples, 3.75%)</title><rect x="48.3138%" y="437" width="3.7460%" height="15" fill="rgb(210,6,40)" fg:x="18882" fg:w="1464"/><text x="48.5638%" y="447.50">std:..</text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (1,462 samples, 3.74%)</title><rect x="48.3189%" y="421" width="3.7409%" height="15" fill="rgb(212,48,18)" fg:x="18884" fg:w="1462"/><text x="48.5689%" y="431.50">std:..</text></g><g><title>core::iter::range::&lt;impl core::iter::traits::iterator::Iterator for core::ops::range::Range&lt;A&gt;&gt;::next (6 samples, 0.02%)</title><rect x="52.0598%" y="453" width="0.0154%" height="15" fill="rgb(230,214,11)" fg:x="20346" fg:w="6"/><text x="52.3098%" y="463.50"></text></g><g><title>&lt;core::ops::range::Range&lt;T&gt; as core::iter::range::RangeIteratorImpl&gt;::spec_next (6 samples, 0.02%)</title><rect x="52.0598%" y="437" width="0.0154%" height="15" fill="rgb(254,105,39)" fg:x="20346" fg:w="6"/><text x="52.3098%" y="447.50"></text></g><g><title>core::mem::drop (25 samples, 0.06%)</title><rect x="52.0751%" y="453" width="0.0640%" height="15" fill="rgb(245,158,5)" fg:x="20352" fg:w="25"/><text x="52.3251%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (25 samples, 0.06%)</title><rect x="52.0751%" y="437" width="0.0640%" height="15" fill="rgb(249,208,11)" fg:x="20352" fg:w="25"/><text x="52.3251%" y="447.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (25 samples, 0.06%)</title><rect x="52.0751%" y="421" width="0.0640%" height="15" fill="rgb(210,39,28)" fg:x="20352" fg:w="25"/><text x="52.3251%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (25 samples, 0.06%)</title><rect x="52.0751%" y="405" width="0.0640%" height="15" fill="rgb(211,56,53)" fg:x="20352" fg:w="25"/><text x="52.3251%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (24 samples, 0.06%)</title><rect x="52.0777%" y="389" width="0.0614%" height="15" fill="rgb(226,201,30)" fg:x="20353" fg:w="24"/><text x="52.3277%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_sub (24 samples, 0.06%)</title><rect x="52.0777%" y="373" width="0.0614%" height="15" fill="rgb(239,101,34)" fg:x="20353" fg:w="24"/><text x="52.3277%" y="383.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (14 samples, 0.04%)</title><rect x="52.1391%" y="453" width="0.0358%" height="15" fill="rgb(226,209,5)" fg:x="20377" fg:w="14"/><text x="52.3891%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (14 samples, 0.04%)</title><rect x="52.1391%" y="437" width="0.0358%" height="15" fill="rgb(250,105,47)" fg:x="20377" fg:w="14"/><text x="52.3891%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (20 samples, 0.05%)</title><rect x="52.1851%" y="421" width="0.0512%" height="15" fill="rgb(230,72,3)" fg:x="20395" fg:w="20"/><text x="52.4351%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (20 samples, 0.05%)</title><rect x="52.1851%" y="405" width="0.0512%" height="15" fill="rgb(232,218,39)" fg:x="20395" fg:w="20"/><text x="52.4351%" y="415.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (22 samples, 0.06%)</title><rect x="52.1851%" y="453" width="0.0563%" height="15" fill="rgb(248,166,6)" fg:x="20395" fg:w="22"/><text x="52.4351%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (22 samples, 0.06%)</title><rect x="52.1851%" y="437" width="0.0563%" height="15" fill="rgb(247,89,20)" fg:x="20395" fg:w="22"/><text x="52.4351%" y="447.50"></text></g><g><title>benchmark::alice_main (18,175 samples, 46.50%)</title><rect x="5.7725%" y="501" width="46.5048%" height="15" fill="rgb(248,130,54)" fg:x="2256" fg:w="18175"/><text x="6.0225%" y="511.50">benchmark::alice_main</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::send (8,691 samples, 22.24%)</title><rect x="30.0394%" y="485" width="22.2379%" height="15" fill="rgb(234,196,4)" fg:x="11740" fg:w="8691"/><text x="30.2894%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::send</text></g><g><title>zssp::zeta::send_payload (8,691 samples, 22.24%)</title><rect x="30.0394%" y="469" width="22.2379%" height="15" fill="rgb(250,143,31)" fg:x="11740" fg:w="8691"/><text x="30.2894%" y="479.50">zssp::zeta::send_payload</text></g><g><title>zssp::zeta::get_counter (14 samples, 0.04%)</title><rect x="52.2414%" y="453" width="0.0358%" height="15" fill="rgb(211,110,34)" fg:x="20417" fg:w="14"/><text x="52.4914%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_add (11 samples, 0.03%)</title><rect x="52.2491%" y="437" width="0.0281%" height="15" fill="rgb(215,124,48)" fg:x="20420" fg:w="11"/><text x="52.4991%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_add (11 samples, 0.03%)</title><rect x="52.2491%" y="421" width="0.0281%" height="15" fill="rgb(216,46,13)" fg:x="20420" fg:w="11"/><text x="52.4991%" y="431.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="52.3745%" y="485" width="0.0384%" height="15" fill="rgb(205,184,25)" fg:x="20469" fg:w="15"/><text x="52.6245%" y="495.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (4 samples, 0.01%)</title><rect x="52.4129%" y="485" width="0.0102%" height="15" fill="rgb(228,1,10)" fg:x="20484" fg:w="4"/><text x="52.6629%" y="495.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (4 samples, 0.01%)</title><rect x="52.4129%" y="469" width="0.0102%" height="15" fill="rgb(213,116,27)" fg:x="20484" fg:w="4"/><text x="52.6629%" y="479.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (4 samples, 0.01%)</title><rect x="52.4129%" y="453" width="0.0102%" height="15" fill="rgb(241,95,50)" fg:x="20484" fg:w="4"/><text x="52.6629%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (10 samples, 0.03%)</title><rect x="52.4257%" y="485" width="0.0256%" height="15" fill="rgb(238,48,32)" fg:x="20489" fg:w="10"/><text x="52.6757%" y="495.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (10 samples, 0.03%)</title><rect x="52.4257%" y="469" width="0.0256%" height="15" fill="rgb(235,113,49)" fg:x="20489" fg:w="10"/><text x="52.6757%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (10 samples, 0.03%)</title><rect x="52.4257%" y="453" width="0.0256%" height="15" fill="rgb(205,127,43)" fg:x="20489" fg:w="10"/><text x="52.6757%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_sub (10 samples, 0.03%)</title><rect x="52.4257%" y="437" width="0.0256%" height="15" fill="rgb(250,162,2)" fg:x="20489" fg:w="10"/><text x="52.6757%" y="447.50"></text></g><g><title>core::time::Duration::as_millis (5 samples, 0.01%)</title><rect x="52.4513%" y="485" width="0.0128%" height="15" fill="rgb(220,13,41)" fg:x="20499" fg:w="5"/><text x="52.7013%" y="495.50"></text></g><g><title>_ZN3std4sync4mpmc5array16Channel$LT$T$GT$10start_recv17h7800ca29c64cb868E.llvm.12455019271255371362 (4 samples, 0.01%)</title><rect x="52.5331%" y="421" width="0.0102%" height="15" fill="rgb(249,221,25)" fg:x="20531" fg:w="4"/><text x="52.7831%" y="431.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (6 samples, 0.02%)</title><rect x="52.5485%" y="421" width="0.0154%" height="15" fill="rgb(215,208,19)" fg:x="20537" fg:w="6"/><text x="52.7985%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (65 samples, 0.17%)</title><rect x="52.6585%" y="405" width="0.1663%" height="15" fill="rgb(236,175,2)" fg:x="20580" fg:w="65"/><text x="52.9085%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (65 samples, 0.17%)</title><rect x="52.6585%" y="389" width="0.1663%" height="15" fill="rgb(241,52,2)" fg:x="20580" fg:w="65"/><text x="52.9085%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (84 samples, 0.21%)</title><rect x="52.8248%" y="405" width="0.2149%" height="15" fill="rgb(248,140,14)" fg:x="20645" fg:w="84"/><text x="53.0748%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (84 samples, 0.21%)</title><rect x="52.8248%" y="389" width="0.2149%" height="15" fill="rgb(253,22,42)" fg:x="20645" fg:w="84"/><text x="53.0748%" y="399.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (190 samples, 0.49%)</title><rect x="52.5638%" y="421" width="0.4862%" height="15" fill="rgb(234,61,47)" fg:x="20543" fg:w="190"/><text x="52.8138%" y="431.50"></text></g><g><title>core::sync::atomic::fence (4 samples, 0.01%)</title><rect x="53.0398%" y="405" width="0.0102%" height="15" fill="rgb(208,226,15)" fg:x="20729" fg:w="4"/><text x="53.2898%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (5 samples, 0.01%)</title><rect x="53.0653%" y="293" width="0.0128%" height="15" fill="rgb(217,221,4)" fg:x="20739" fg:w="5"/><text x="53.3153%" y="303.50"></text></g><g><title>core::sync::atomic::atomic_swap (5 samples, 0.01%)</title><rect x="53.0653%" y="277" width="0.0128%" height="15" fill="rgb(212,174,34)" fg:x="20739" fg:w="5"/><text x="53.3153%" y="287.50"></text></g><g><title>[[vdso]] (4 samples, 0.01%)</title><rect x="53.0807%" y="213" width="0.0102%" height="15" fill="rgb(253,83,4)" fg:x="20745" fg:w="4"/><text x="53.3307%" y="223.50"></text></g><g><title>core::option::Option&lt;T&gt;::and_then (5 samples, 0.01%)</title><rect x="53.0807%" y="277" width="0.0128%" height="15" fill="rgb(250,195,49)" fg:x="20745" fg:w="5"/><text x="53.3307%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wait::_{{closure}} (5 samples, 0.01%)</title><rect x="53.0807%" y="261" width="0.0128%" height="15" fill="rgb(241,192,25)" fg:x="20745" fg:w="5"/><text x="53.3307%" y="271.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (5 samples, 0.01%)</title><rect x="53.0807%" y="245" width="0.0128%" height="15" fill="rgb(208,124,10)" fg:x="20745" fg:w="5"/><text x="53.3307%" y="255.50"></text></g><g><title>clock_gettime (5 samples, 0.01%)</title><rect x="53.0807%" y="229" width="0.0128%" height="15" fill="rgb(222,33,0)" fg:x="20745" fg:w="5"/><text x="53.3307%" y="239.50"></text></g><g><title>futex_setup_timer (5 samples, 0.01%)</title><rect x="53.1396%" y="181" width="0.0128%" height="15" fill="rgb(234,209,28)" fg:x="20768" fg:w="5"/><text x="53.3896%" y="191.50"></text></g><g><title>hrtimer_init_sleeper (4 samples, 0.01%)</title><rect x="53.1421%" y="165" width="0.0102%" height="15" fill="rgb(224,11,23)" fg:x="20769" fg:w="4"/><text x="53.3921%" y="175.50"></text></g><g><title>__hrtimer_init (4 samples, 0.01%)</title><rect x="53.1421%" y="149" width="0.0102%" height="15" fill="rgb(232,99,1)" fg:x="20769" fg:w="4"/><text x="53.3921%" y="159.50"></text></g><g><title>futex_unqueue (4 samples, 0.01%)</title><rect x="53.1523%" y="181" width="0.0102%" height="15" fill="rgb(237,95,45)" fg:x="20773" fg:w="4"/><text x="53.4023%" y="191.50"></text></g><g><title>hrtimer_sleeper_start_expires (6 samples, 0.02%)</title><rect x="53.1651%" y="165" width="0.0154%" height="15" fill="rgb(208,109,11)" fg:x="20778" fg:w="6"/><text x="53.4151%" y="175.50"></text></g><g><title>hrtimer_start_range_ns (6 samples, 0.02%)</title><rect x="53.1651%" y="149" width="0.0154%" height="15" fill="rgb(216,190,48)" fg:x="20778" fg:w="6"/><text x="53.4151%" y="159.50"></text></g><g><title>update_curr (5 samples, 0.01%)</title><rect x="53.2342%" y="85" width="0.0128%" height="15" fill="rgb(251,171,36)" fg:x="20805" fg:w="5"/><text x="53.4842%" y="95.50"></text></g><g><title>dequeue_entity (14 samples, 0.04%)</title><rect x="53.2240%" y="101" width="0.0358%" height="15" fill="rgb(230,62,22)" fg:x="20801" fg:w="14"/><text x="53.4740%" y="111.50"></text></g><g><title>update_load_avg (5 samples, 0.01%)</title><rect x="53.2470%" y="85" width="0.0128%" height="15" fill="rgb(225,114,35)" fg:x="20810" fg:w="5"/><text x="53.4970%" y="95.50"></text></g><g><title>dequeue_task (18 samples, 0.05%)</title><rect x="53.2189%" y="133" width="0.0461%" height="15" fill="rgb(215,118,42)" fg:x="20799" fg:w="18"/><text x="53.4689%" y="143.50"></text></g><g><title>dequeue_task_fair (18 samples, 0.05%)</title><rect x="53.2189%" y="117" width="0.0461%" height="15" fill="rgb(243,119,21)" fg:x="20799" fg:w="18"/><text x="53.4689%" y="127.50"></text></g><g><title>finish_task_switch.isra.0 (14 samples, 0.04%)</title><rect x="53.2649%" y="133" width="0.0358%" height="15" fill="rgb(252,177,53)" fg:x="20817" fg:w="14"/><text x="53.5149%" y="143.50"></text></g><g><title>raw_spin_rq_unlock (6 samples, 0.02%)</title><rect x="53.2854%" y="117" width="0.0154%" height="15" fill="rgb(237,209,29)" fg:x="20825" fg:w="6"/><text x="53.5354%" y="127.50"></text></g><g><title>pick_next_task (5 samples, 0.01%)</title><rect x="53.3008%" y="133" width="0.0128%" height="15" fill="rgb(212,65,23)" fg:x="20831" fg:w="5"/><text x="53.5508%" y="143.50"></text></g><g><title>prepare_task_switch (6 samples, 0.02%)</title><rect x="53.3135%" y="133" width="0.0154%" height="15" fill="rgb(230,222,46)" fg:x="20836" fg:w="6"/><text x="53.5635%" y="143.50"></text></g><g><title>__perf_event_task_sched_out (4 samples, 0.01%)</title><rect x="53.3187%" y="117" width="0.0102%" height="15" fill="rgb(215,135,32)" fg:x="20838" fg:w="4"/><text x="53.5687%" y="127.50"></text></g><g><title>psi_group_change (12 samples, 0.03%)</title><rect x="53.3391%" y="117" width="0.0307%" height="15" fill="rgb(246,101,22)" fg:x="20846" fg:w="12"/><text x="53.5891%" y="127.50"></text></g><g><title>record_times (5 samples, 0.01%)</title><rect x="53.3698%" y="117" width="0.0128%" height="15" fill="rgb(206,107,13)" fg:x="20858" fg:w="5"/><text x="53.6198%" y="127.50"></text></g><g><title>psi_task_switch (22 samples, 0.06%)</title><rect x="53.3315%" y="133" width="0.0563%" height="15" fill="rgb(250,100,44)" fg:x="20843" fg:w="22"/><text x="53.5815%" y="143.50"></text></g><g><title>__schedule (72 samples, 0.18%)</title><rect x="53.2061%" y="149" width="0.1842%" height="15" fill="rgb(231,147,38)" fg:x="20794" fg:w="72"/><text x="53.4561%" y="159.50"></text></g><g><title>futex_wait_queue (90 samples, 0.23%)</title><rect x="53.1626%" y="181" width="0.2303%" height="15" fill="rgb(229,8,40)" fg:x="20777" fg:w="90"/><text x="53.4126%" y="191.50"></text></g><g><title>schedule (81 samples, 0.21%)</title><rect x="53.1856%" y="165" width="0.2073%" height="15" fill="rgb(221,135,30)" fg:x="20786" fg:w="81"/><text x="53.4356%" y="175.50"></text></g><g><title>__get_user_nocheck_4 (6 samples, 0.02%)</title><rect x="53.3929%" y="165" width="0.0154%" height="15" fill="rgb(249,193,18)" fg:x="20867" fg:w="6"/><text x="53.6429%" y="175.50"></text></g><g><title>futex_q_lock (7 samples, 0.02%)</title><rect x="53.4210%" y="165" width="0.0179%" height="15" fill="rgb(209,133,39)" fg:x="20878" fg:w="7"/><text x="53.6710%" y="175.50"></text></g><g><title>futex_wait_setup (19 samples, 0.05%)</title><rect x="53.3929%" y="181" width="0.0486%" height="15" fill="rgb(232,100,14)" fg:x="20867" fg:w="19"/><text x="53.6429%" y="191.50"></text></g><g><title>hrtimer_cancel (5 samples, 0.01%)</title><rect x="53.4415%" y="181" width="0.0128%" height="15" fill="rgb(224,185,1)" fg:x="20886" fg:w="5"/><text x="53.6915%" y="191.50"></text></g><g><title>hrtimer_try_to_cancel (5 samples, 0.01%)</title><rect x="53.4415%" y="165" width="0.0128%" height="15" fill="rgb(223,139,8)" fg:x="20886" fg:w="5"/><text x="53.6915%" y="175.50"></text></g><g><title>do_futex (131 samples, 0.34%)</title><rect x="53.1268%" y="213" width="0.3352%" height="15" fill="rgb(232,213,38)" fg:x="20763" fg:w="131"/><text x="53.3768%" y="223.50"></text></g><g><title>futex_wait (130 samples, 0.33%)</title><rect x="53.1293%" y="197" width="0.3326%" height="15" fill="rgb(207,94,22)" fg:x="20764" fg:w="130"/><text x="53.3793%" y="207.50"></text></g><g><title>__x64_sys_futex (143 samples, 0.37%)</title><rect x="53.1088%" y="229" width="0.3659%" height="15" fill="rgb(219,183,54)" fg:x="20756" fg:w="143"/><text x="53.3588%" y="239.50"></text></g><g><title>get_timespec64 (5 samples, 0.01%)</title><rect x="53.4620%" y="213" width="0.0128%" height="15" fill="rgb(216,185,54)" fg:x="20894" fg:w="5"/><text x="53.7120%" y="223.50"></text></g><g><title>exit_to_user_mode_loop (11 samples, 0.03%)</title><rect x="53.4773%" y="197" width="0.0281%" height="15" fill="rgb(254,217,39)" fg:x="20900" fg:w="11"/><text x="53.7273%" y="207.50"></text></g><g><title>__rseq_handle_notify_resume (4 samples, 0.01%)</title><rect x="53.4952%" y="181" width="0.0102%" height="15" fill="rgb(240,178,23)" fg:x="20907" fg:w="4"/><text x="53.7452%" y="191.50"></text></g><g><title>std::sync::mpmc::context::Context::wait_until (178 samples, 0.46%)</title><rect x="53.0577%" y="341" width="0.4555%" height="15" fill="rgb(218,11,47)" fg:x="20736" fg:w="178"/><text x="53.3077%" y="351.50"></text></g><g><title>std::thread::park_timeout (177 samples, 0.45%)</title><rect x="53.0602%" y="325" width="0.4529%" height="15" fill="rgb(218,51,51)" fg:x="20737" fg:w="177"/><text x="53.3102%" y="335.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::park_timeout (175 samples, 0.45%)</title><rect x="53.0653%" y="309" width="0.4478%" height="15" fill="rgb(238,126,27)" fg:x="20739" fg:w="175"/><text x="53.3153%" y="319.50"></text></g><g><title>std::sys::unix::futex::futex_wait (170 samples, 0.43%)</title><rect x="53.0781%" y="293" width="0.4350%" height="15" fill="rgb(249,202,22)" fg:x="20744" fg:w="170"/><text x="53.3281%" y="303.50"></text></g><g><title>syscall (164 samples, 0.42%)</title><rect x="53.0935%" y="277" width="0.4196%" height="15" fill="rgb(254,195,49)" fg:x="20750" fg:w="164"/><text x="53.3435%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (159 samples, 0.41%)</title><rect x="53.1063%" y="261" width="0.4068%" height="15" fill="rgb(208,123,14)" fg:x="20755" fg:w="159"/><text x="53.3563%" y="271.50"></text></g><g><title>do_syscall_64 (159 samples, 0.41%)</title><rect x="53.1063%" y="245" width="0.4068%" height="15" fill="rgb(224,200,8)" fg:x="20755" fg:w="159"/><text x="53.3563%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (15 samples, 0.04%)</title><rect x="53.4747%" y="229" width="0.0384%" height="15" fill="rgb(217,61,36)" fg:x="20899" fg:w="15"/><text x="53.7247%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (15 samples, 0.04%)</title><rect x="53.4747%" y="213" width="0.0384%" height="15" fill="rgb(206,35,45)" fg:x="20899" fg:w="15"/><text x="53.7247%" y="223.50"></text></g><g><title>core::sync::atomic::AtomicBool::store (8 samples, 0.02%)</title><rect x="53.5208%" y="325" width="0.0205%" height="15" fill="rgb(217,65,33)" fg:x="20917" fg:w="8"/><text x="53.7708%" y="335.50"></text></g><g><title>core::sync::atomic::atomic_store (8 samples, 0.02%)</title><rect x="53.5208%" y="309" width="0.0205%" height="15" fill="rgb(222,158,48)" fg:x="20917" fg:w="8"/><text x="53.7708%" y="319.50"></text></g><g><title>std::sync::mpmc::waker::Waker::register (5 samples, 0.01%)</title><rect x="53.5413%" y="325" width="0.0128%" height="15" fill="rgb(254,2,54)" fg:x="20925" fg:w="5"/><text x="53.7913%" y="335.50"></text></g><g><title>std::sync::mpmc::waker::Waker::register_with_packet (5 samples, 0.01%)</title><rect x="53.5413%" y="309" width="0.0128%" height="15" fill="rgb(250,143,38)" fg:x="20925" fg:w="5"/><text x="53.7913%" y="319.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::push (5 samples, 0.01%)</title><rect x="53.5413%" y="293" width="0.0128%" height="15" fill="rgb(248,25,0)" fg:x="20925" fg:w="5"/><text x="53.7913%" y="303.50"></text></g><g><title>core::ptr::write (5 samples, 0.01%)</title><rect x="53.5413%" y="277" width="0.0128%" height="15" fill="rgb(206,152,27)" fg:x="20925" fg:w="5"/><text x="53.7913%" y="287.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::register (24 samples, 0.06%)</title><rect x="53.5131%" y="341" width="0.0614%" height="15" fill="rgb(240,77,30)" fg:x="20914" fg:w="24"/><text x="53.7631%" y="351.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (8 samples, 0.02%)</title><rect x="53.5541%" y="325" width="0.0205%" height="15" fill="rgb(231,5,3)" fg:x="20930" fg:w="8"/><text x="53.8041%" y="335.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (8 samples, 0.02%)</title><rect x="53.5541%" y="309" width="0.0205%" height="15" fill="rgb(207,226,32)" fg:x="20930" fg:w="8"/><text x="53.8041%" y="319.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (8 samples, 0.02%)</title><rect x="53.5541%" y="293" width="0.0205%" height="15" fill="rgb(222,207,47)" fg:x="20930" fg:w="8"/><text x="53.8041%" y="303.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (8 samples, 0.02%)</title><rect x="53.5541%" y="277" width="0.0205%" height="15" fill="rgb(229,115,45)" fg:x="20930" fg:w="8"/><text x="53.8041%" y="287.50"></text></g><g><title>std::sync::mpmc::context::Context::with (207 samples, 0.53%)</title><rect x="53.0500%" y="421" width="0.5297%" height="15" fill="rgb(224,191,6)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="431.50"></text></g><g><title>std::thread::local::LocalKey&lt;T&gt;::try_with (207 samples, 0.53%)</title><rect x="53.0500%" y="405" width="0.5297%" height="15" fill="rgb(230,227,24)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="415.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (207 samples, 0.53%)</title><rect x="53.0500%" y="389" width="0.5297%" height="15" fill="rgb(228,80,19)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="399.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (207 samples, 0.53%)</title><rect x="53.0500%" y="373" width="0.5297%" height="15" fill="rgb(247,229,0)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="383.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv::_{{closure}} (207 samples, 0.53%)</title><rect x="53.0500%" y="357" width="0.5297%" height="15" fill="rgb(237,194,15)" fg:x="20733" fg:w="207"/><text x="53.3000%" y="367.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_deadline (431 samples, 1.10%)</title><rect x="52.4896%" y="453" width="1.1028%" height="15" fill="rgb(219,203,20)" fg:x="20514" fg:w="431"/><text x="52.7396%" y="463.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv (431 samples, 1.10%)</title><rect x="52.4896%" y="437" width="1.1028%" height="15" fill="rgb(234,128,8)" fg:x="20514" fg:w="431"/><text x="52.7396%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (5 samples, 0.01%)</title><rect x="53.5797%" y="421" width="0.0128%" height="15" fill="rgb(248,202,8)" fg:x="20940" fg:w="5"/><text x="53.8297%" y="431.50"></text></g><g><title>clock_gettime (5 samples, 0.01%)</title><rect x="53.5797%" y="405" width="0.0128%" height="15" fill="rgb(206,104,37)" fg:x="20940" fg:w="5"/><text x="53.8297%" y="415.50"></text></g><g><title>[[vdso]] (5 samples, 0.01%)</title><rect x="53.5797%" y="389" width="0.0128%" height="15" fill="rgb(223,8,27)" fg:x="20940" fg:w="5"/><text x="53.8297%" y="399.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (4 samples, 0.01%)</title><rect x="53.5924%" y="453" width="0.0102%" height="15" fill="rgb(216,217,28)" fg:x="20945" fg:w="4"/><text x="53.8424%" y="463.50"></text></g><g><title>[[vdso]] (131 samples, 0.34%)</title><rect x="53.6257%" y="421" width="0.3352%" height="15" fill="rgb(249,199,1)" fg:x="20958" fg:w="131"/><text x="53.8757%" y="431.50"></text></g><g><title>[[vdso]] (88 samples, 0.23%)</title><rect x="53.7357%" y="405" width="0.2252%" height="15" fill="rgb(240,85,17)" fg:x="21001" fg:w="88"/><text x="53.9857%" y="415.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (146 samples, 0.37%)</title><rect x="53.6027%" y="453" width="0.3736%" height="15" fill="rgb(206,108,45)" fg:x="20949" fg:w="146"/><text x="53.8527%" y="463.50"></text></g><g><title>clock_gettime (140 samples, 0.36%)</title><rect x="53.6180%" y="437" width="0.3582%" height="15" fill="rgb(245,210,41)" fg:x="20955" fg:w="140"/><text x="53.8680%" y="447.50"></text></g><g><title>__vdso_clock_gettime (6 samples, 0.02%)</title><rect x="53.9609%" y="421" width="0.0154%" height="15" fill="rgb(206,13,37)" fg:x="21089" fg:w="6"/><text x="54.2109%" y="431.50"></text></g><g><title>std::sync::mpsc::Receiver&lt;T&gt;::recv_timeout (605 samples, 1.55%)</title><rect x="52.4640%" y="485" width="1.5480%" height="15" fill="rgb(250,61,18)" fg:x="20504" fg:w="605"/><text x="52.7140%" y="495.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (602 samples, 1.54%)</title><rect x="52.4717%" y="469" width="1.5404%" height="15" fill="rgb(235,172,48)" fg:x="20507" fg:w="602"/><text x="52.7217%" y="479.50"></text></g><g><title>std::time::SystemTime::checked_add (12 samples, 0.03%)</title><rect x="53.9814%" y="453" width="0.0307%" height="15" fill="rgb(249,201,17)" fg:x="21097" fg:w="12"/><text x="54.2314%" y="463.50"></text></g><g><title>std::sys::unix::time::SystemTime::checked_add_duration (12 samples, 0.03%)</title><rect x="53.9814%" y="437" width="0.0307%" height="15" fill="rgb(219,208,6)" fg:x="21097" fg:w="12"/><text x="54.2314%" y="447.50"></text></g><g><title>std::sys::unix::time::Timespec::checked_add_duration (12 samples, 0.03%)</title><rect x="53.9814%" y="421" width="0.0307%" height="15" fill="rgb(248,31,23)" fg:x="21097" fg:w="12"/><text x="54.2314%" y="431.50"></text></g><g><title>core::option::Option&lt;T&gt;::and_then (4 samples, 0.01%)</title><rect x="54.0018%" y="405" width="0.0102%" height="15" fill="rgb(245,15,42)" fg:x="21105" fg:w="4"/><text x="54.2518%" y="415.50"></text></g><g><title>core::cmp::impls::&lt;impl core::cmp::PartialOrd&lt;&amp;B&gt; for &amp;A&gt;::ge (6 samples, 0.02%)</title><rect x="54.0607%" y="389" width="0.0154%" height="15" fill="rgb(222,217,39)" fg:x="21128" fg:w="6"/><text x="54.3107%" y="399.50"></text></g><g><title>core::cmp::PartialOrd::ge (6 samples, 0.02%)</title><rect x="54.0607%" y="373" width="0.0154%" height="15" fill="rgb(210,219,27)" fg:x="21128" fg:w="6"/><text x="54.3107%" y="383.50"></text></g><g><title>&lt;std::sys::unix::time::Timespec as core::cmp::PartialOrd&gt;::partial_cmp (5 samples, 0.01%)</title><rect x="54.0633%" y="357" width="0.0128%" height="15" fill="rgb(252,166,36)" fg:x="21129" fg:w="5"/><text x="54.3133%" y="367.50"></text></g><g><title>std::time::Instant::duration_since (22 samples, 0.06%)</title><rect x="54.0274%" y="453" width="0.0563%" height="15" fill="rgb(245,132,34)" fg:x="21115" fg:w="22"/><text x="54.2774%" y="463.50"></text></g><g><title>std::time::Instant::checked_duration_since (21 samples, 0.05%)</title><rect x="54.0300%" y="437" width="0.0537%" height="15" fill="rgb(236,54,3)" fg:x="21116" fg:w="21"/><text x="54.2800%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (21 samples, 0.05%)</title><rect x="54.0300%" y="421" width="0.0537%" height="15" fill="rgb(241,173,43)" fg:x="21116" fg:w="21"/><text x="54.2800%" y="431.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (21 samples, 0.05%)</title><rect x="54.0300%" y="405" width="0.0537%" height="15" fill="rgb(215,190,9)" fg:x="21116" fg:w="21"/><text x="54.2800%" y="415.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (27 samples, 0.07%)</title><rect x="54.0274%" y="469" width="0.0691%" height="15" fill="rgb(242,101,16)" fg:x="21115" fg:w="27"/><text x="54.2774%" y="479.50"></text></g><g><title>std::time::Instant::elapsed (5 samples, 0.01%)</title><rect x="54.0837%" y="453" width="0.0128%" height="15" fill="rgb(223,190,21)" fg:x="21137" fg:w="5"/><text x="54.3337%" y="463.50"></text></g><g><title>[[vdso]] (148 samples, 0.38%)</title><rect x="54.1144%" y="405" width="0.3787%" height="15" fill="rgb(215,228,25)" fg:x="21149" fg:w="148"/><text x="54.3644%" y="415.50"></text></g><g><title>[[vdso]] (107 samples, 0.27%)</title><rect x="54.2193%" y="389" width="0.2738%" height="15" fill="rgb(225,36,22)" fg:x="21190" fg:w="107"/><text x="54.4693%" y="399.50"></text></g><g><title>std::time::Instant::elapsed (192 samples, 0.49%)</title><rect x="54.0121%" y="485" width="0.4913%" height="15" fill="rgb(251,106,46)" fg:x="21109" fg:w="192"/><text x="54.2621%" y="495.50"></text></g><g><title>std::time::Instant::now (159 samples, 0.41%)</title><rect x="54.0965%" y="469" width="0.4068%" height="15" fill="rgb(208,90,1)" fg:x="21142" fg:w="159"/><text x="54.3465%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::Instant::now (159 samples, 0.41%)</title><rect x="54.0965%" y="453" width="0.4068%" height="15" fill="rgb(243,10,4)" fg:x="21142" fg:w="159"/><text x="54.3465%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (155 samples, 0.40%)</title><rect x="54.1067%" y="437" width="0.3966%" height="15" fill="rgb(212,137,27)" fg:x="21146" fg:w="155"/><text x="54.3567%" y="447.50"></text></g><g><title>clock_gettime (154 samples, 0.39%)</title><rect x="54.1093%" y="421" width="0.3940%" height="15" fill="rgb(231,220,49)" fg:x="21147" fg:w="154"/><text x="54.3593%" y="431.50"></text></g><g><title>__vdso_clock_gettime (4 samples, 0.01%)</title><rect x="54.4931%" y="405" width="0.0102%" height="15" fill="rgb(237,96,20)" fg:x="21297" fg:w="4"/><text x="54.7431%" y="415.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (306 samples, 0.78%)</title><rect x="54.7029%" y="469" width="0.7830%" height="15" fill="rgb(239,229,30)" fg:x="21379" fg:w="306"/><text x="54.9529%" y="479.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (306 samples, 0.78%)</title><rect x="54.7029%" y="453" width="0.7830%" height="15" fill="rgb(219,65,33)" fg:x="21379" fg:w="306"/><text x="54.9529%" y="463.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (306 samples, 0.78%)</title><rect x="54.7029%" y="437" width="0.7830%" height="15" fill="rgb(243,134,7)" fg:x="21379" fg:w="306"/><text x="54.9529%" y="447.50"></text></g><g><title>&lt;core::result::Result&lt;T,E&gt; as core::ops::try_trait::Try&gt;::branch (13 samples, 0.03%)</title><rect x="55.4859%" y="469" width="0.0333%" height="15" fill="rgb(216,177,54)" fg:x="21685" fg:w="13"/><text x="55.7359%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (61 samples, 0.16%)</title><rect x="55.5345%" y="453" width="0.1561%" height="15" fill="rgb(211,160,20)" fg:x="21704" fg:w="61"/><text x="55.7845%" y="463.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (61 samples, 0.16%)</title><rect x="55.5345%" y="437" width="0.1561%" height="15" fill="rgb(239,85,39)" fg:x="21704" fg:w="61"/><text x="55.7845%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (60 samples, 0.15%)</title><rect x="55.5371%" y="421" width="0.1535%" height="15" fill="rgb(232,125,22)" fg:x="21705" fg:w="60"/><text x="55.7871%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (56 samples, 0.14%)</title><rect x="55.5473%" y="405" width="0.1433%" height="15" fill="rgb(244,57,34)" fg:x="21709" fg:w="56"/><text x="55.7973%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_swap (56 samples, 0.14%)</title><rect x="55.5473%" y="389" width="0.1433%" height="15" fill="rgb(214,203,32)" fg:x="21709" fg:w="56"/><text x="55.7973%" y="399.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (6 samples, 0.02%)</title><rect x="55.6906%" y="437" width="0.0154%" height="15" fill="rgb(207,58,43)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="447.50"></text></g><g><title>std::sync::poison::Flag::guard (6 samples, 0.02%)</title><rect x="55.6906%" y="421" width="0.0154%" height="15" fill="rgb(215,193,15)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="431.50"></text></g><g><title>std::thread::panicking (6 samples, 0.02%)</title><rect x="55.6906%" y="405" width="0.0154%" height="15" fill="rgb(232,15,44)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="415.50"></text></g><g><title>std::panicking::panicking (6 samples, 0.02%)</title><rect x="55.6906%" y="389" width="0.0154%" height="15" fill="rgb(212,3,48)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="399.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (6 samples, 0.02%)</title><rect x="55.6906%" y="373" width="0.0154%" height="15" fill="rgb(218,128,7)" fg:x="21765" fg:w="6"/><text x="55.9406%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (77 samples, 0.20%)</title><rect x="55.6906%" y="453" width="0.1970%" height="15" fill="rgb(226,216,39)" fg:x="21765" fg:w="77"/><text x="55.9406%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (71 samples, 0.18%)</title><rect x="55.7060%" y="437" width="0.1817%" height="15" fill="rgb(243,47,51)" fg:x="21771" fg:w="71"/><text x="55.9560%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (69 samples, 0.18%)</title><rect x="55.7111%" y="421" width="0.1766%" height="15" fill="rgb(241,183,40)" fg:x="21773" fg:w="69"/><text x="55.9611%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (69 samples, 0.18%)</title><rect x="55.7111%" y="405" width="0.1766%" height="15" fill="rgb(231,217,32)" fg:x="21773" fg:w="69"/><text x="55.9611%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_get_block_size (5 samples, 0.01%)</title><rect x="55.9618%" y="421" width="0.0128%" height="15" fill="rgb(229,61,38)" fg:x="21871" fg:w="5"/><text x="56.2118%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (344 samples, 0.88%)</title><rect x="55.5192%" y="469" width="0.8802%" height="15" fill="rgb(225,210,5)" fg:x="21698" fg:w="344"/><text x="55.7692%" y="479.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (200 samples, 0.51%)</title><rect x="55.8876%" y="453" width="0.5117%" height="15" fill="rgb(231,79,45)" fg:x="21842" fg:w="200"/><text x="56.1376%" y="463.50"></text></g><g><title>EVP_DecryptUpdate (196 samples, 0.50%)</title><rect x="55.8979%" y="437" width="0.5015%" height="15" fill="rgb(224,100,7)" fg:x="21846" fg:w="196"/><text x="56.1479%" y="447.50"></text></g><g><title>[libcrypto.so.3] (166 samples, 0.42%)</title><rect x="55.9746%" y="421" width="0.4247%" height="15" fill="rgb(241,198,18)" fg:x="21876" fg:w="166"/><text x="56.2246%" y="431.50"></text></g><g><title>[libcrypto.so.3] (119 samples, 0.30%)</title><rect x="56.0949%" y="405" width="0.3045%" height="15" fill="rgb(252,97,53)" fg:x="21923" fg:w="119"/><text x="56.3449%" y="415.50"></text></g><g><title>[libcrypto.so.3] (113 samples, 0.29%)</title><rect x="56.1102%" y="389" width="0.2891%" height="15" fill="rgb(220,88,7)" fg:x="21929" fg:w="113"/><text x="56.3602%" y="399.50"></text></g><g><title>__rust_probestack (9 samples, 0.02%)</title><rect x="56.3994%" y="469" width="0.0230%" height="15" fill="rgb(213,176,14)" fg:x="22042" fg:w="9"/><text x="56.6494%" y="479.50"></text></g><g><title>core::cmp::Ord::max (5 samples, 0.01%)</title><rect x="56.4250%" y="469" width="0.0128%" height="15" fill="rgb(246,73,7)" fg:x="22052" fg:w="5"/><text x="56.6750%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (5 samples, 0.01%)</title><rect x="56.4250%" y="453" width="0.0128%" height="15" fill="rgb(245,64,36)" fg:x="22052" fg:w="5"/><text x="56.6750%" y="463.50"></text></g><g><title>core::num::nonzero::NonZeroU32::new (6 samples, 0.02%)</title><rect x="56.4377%" y="469" width="0.0154%" height="15" fill="rgb(245,80,10)" fg:x="22057" fg:w="6"/><text x="56.6877%" y="479.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="56.4403%" y="453" width="0.0128%" height="15" fill="rgb(232,107,50)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="463.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="56.4403%" y="437" width="0.0128%" height="15" fill="rgb(253,3,0)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="447.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="56.4403%" y="421" width="0.0128%" height="15" fill="rgb(212,99,53)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="431.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="56.4403%" y="405" width="0.0128%" height="15" fill="rgb(249,111,54)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="415.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="56.4403%" y="389" width="0.0128%" height="15" fill="rgb(249,55,30)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="399.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="56.4403%" y="373" width="0.0128%" height="15" fill="rgb(237,47,42)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="383.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="56.4403%" y="357" width="0.0128%" height="15" fill="rgb(211,20,18)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="367.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="56.4403%" y="341" width="0.0128%" height="15" fill="rgb(231,203,46)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="351.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="56.4403%" y="325" width="0.0128%" height="15" fill="rgb(237,142,3)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="335.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="56.4403%" y="309" width="0.0128%" height="15" fill="rgb(241,107,1)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="319.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="56.4403%" y="293" width="0.0128%" height="15" fill="rgb(229,83,13)" fg:x="22058" fg:w="5"/><text x="56.6903%" y="303.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade::_{{closure}} (7 samples, 0.02%)</title><rect x="56.4710%" y="405" width="0.0179%" height="15" fill="rgb(241,91,40)" fg:x="22070" fg:w="7"/><text x="56.7210%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (43 samples, 0.11%)</title><rect x="56.4889%" y="405" width="0.1100%" height="15" fill="rgb(225,3,45)" fg:x="22077" fg:w="43"/><text x="56.7389%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (43 samples, 0.11%)</title><rect x="56.4889%" y="389" width="0.1100%" height="15" fill="rgb(244,223,14)" fg:x="22077" fg:w="43"/><text x="56.7389%" y="399.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade (63 samples, 0.16%)</title><rect x="56.4531%" y="437" width="0.1612%" height="15" fill="rgb(224,124,37)" fg:x="22063" fg:w="63"/><text x="56.7031%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_update (61 samples, 0.16%)</title><rect x="56.4582%" y="421" width="0.1561%" height="15" fill="rgb(251,171,30)" fg:x="22065" fg:w="61"/><text x="56.7082%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (6 samples, 0.02%)</title><rect x="56.5989%" y="405" width="0.0154%" height="15" fill="rgb(236,46,54)" fg:x="22120" fg:w="6"/><text x="56.8489%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="56.5989%" y="389" width="0.0154%" height="15" fill="rgb(245,213,5)" fg:x="22120" fg:w="6"/><text x="56.8489%" y="399.50"></text></g><g><title>core::option::Option&lt;T&gt;::map (71 samples, 0.18%)</title><rect x="56.4531%" y="469" width="0.1817%" height="15" fill="rgb(230,144,27)" fg:x="22063" fg:w="71"/><text x="56.7031%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive::_{{closure}} (71 samples, 0.18%)</title><rect x="56.4531%" y="453" width="0.1817%" height="15" fill="rgb(220,86,6)" fg:x="22063" fg:w="71"/><text x="56.7031%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8 samples, 0.02%)</title><rect x="56.6143%" y="437" width="0.0205%" height="15" fill="rgb(240,20,13)" fg:x="22126" fg:w="8"/><text x="56.8643%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (55 samples, 0.14%)</title><rect x="56.6348%" y="469" width="0.1407%" height="15" fill="rgb(217,89,34)" fg:x="22134" fg:w="55"/><text x="56.8848%" y="479.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (55 samples, 0.14%)</title><rect x="56.6348%" y="453" width="0.1407%" height="15" fill="rgb(229,13,5)" fg:x="22134" fg:w="55"/><text x="56.8848%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (53 samples, 0.14%)</title><rect x="56.6399%" y="437" width="0.1356%" height="15" fill="rgb(244,67,35)" fg:x="22136" fg:w="53"/><text x="56.8899%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_sub (53 samples, 0.14%)</title><rect x="56.6399%" y="421" width="0.1356%" height="15" fill="rgb(221,40,2)" fg:x="22136" fg:w="53"/><text x="56.8899%" y="431.50"></text></g><g><title>__rdl_dealloc (4 samples, 0.01%)</title><rect x="56.7832%" y="293" width="0.0102%" height="15" fill="rgb(237,157,21)" fg:x="22192" fg:w="4"/><text x="57.0332%" y="303.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::dealloc (4 samples, 0.01%)</title><rect x="56.7832%" y="277" width="0.0102%" height="15" fill="rgb(222,94,11)" fg:x="22192" fg:w="4"/><text x="57.0332%" y="287.50"></text></g><g><title>[libc.so.6] (73 samples, 0.19%)</title><rect x="57.9346%" y="261" width="0.1868%" height="15" fill="rgb(249,113,6)" fg:x="22642" fg:w="73"/><text x="58.1846%" y="271.50"></text></g><g><title>__entry_text_start (13 samples, 0.03%)</title><rect x="58.2109%" y="245" width="0.0333%" height="15" fill="rgb(238,137,36)" fg:x="22750" fg:w="13"/><text x="58.4609%" y="255.50"></text></g><g><title>futex_unqueue (8 samples, 0.02%)</title><rect x="58.3133%" y="165" width="0.0205%" height="15" fill="rgb(210,102,26)" fg:x="22790" fg:w="8"/><text x="58.5633%" y="175.50"></text></g><g><title>update_curr (16 samples, 0.04%)</title><rect x="58.4131%" y="69" width="0.0409%" height="15" fill="rgb(218,30,30)" fg:x="22829" fg:w="16"/><text x="58.6631%" y="79.50"></text></g><g><title>cpuacct_charge (8 samples, 0.02%)</title><rect x="58.4335%" y="53" width="0.0205%" height="15" fill="rgb(214,67,26)" fg:x="22837" fg:w="8"/><text x="58.6835%" y="63.50"></text></g><g><title>dequeue_entity (23 samples, 0.06%)</title><rect x="58.4054%" y="85" width="0.0589%" height="15" fill="rgb(251,9,53)" fg:x="22826" fg:w="23"/><text x="58.6554%" y="95.50"></text></g><g><title>update_load_avg (4 samples, 0.01%)</title><rect x="58.4540%" y="69" width="0.0102%" height="15" fill="rgb(228,204,25)" fg:x="22845" fg:w="4"/><text x="58.7040%" y="79.50"></text></g><g><title>dequeue_task_fair (28 samples, 0.07%)</title><rect x="58.4003%" y="101" width="0.0716%" height="15" fill="rgb(207,153,8)" fg:x="22824" fg:w="28"/><text x="58.6503%" y="111.50"></text></g><g><title>dequeue_task (29 samples, 0.07%)</title><rect x="58.4003%" y="117" width="0.0742%" height="15" fill="rgb(242,9,16)" fg:x="22824" fg:w="29"/><text x="58.6503%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (8 samples, 0.02%)</title><rect x="58.4822%" y="101" width="0.0205%" height="15" fill="rgb(217,211,10)" fg:x="22856" fg:w="8"/><text x="58.7322%" y="111.50"></text></g><g><title>perf_ctx_enable (8 samples, 0.02%)</title><rect x="58.4822%" y="85" width="0.0205%" height="15" fill="rgb(219,228,52)" fg:x="22856" fg:w="8"/><text x="58.7322%" y="95.50"></text></g><g><title>x86_pmu_enable (4 samples, 0.01%)</title><rect x="58.4924%" y="69" width="0.0102%" height="15" fill="rgb(231,92,29)" fg:x="22860" fg:w="4"/><text x="58.7424%" y="79.50"></text></g><g><title>intel_pmu_enable_all (4 samples, 0.01%)</title><rect x="58.4924%" y="53" width="0.0102%" height="15" fill="rgb(232,8,23)" fg:x="22860" fg:w="4"/><text x="58.7424%" y="63.50"></text></g><g><title>native_write_msr (4 samples, 0.01%)</title><rect x="58.4924%" y="37" width="0.0102%" height="15" fill="rgb(216,211,34)" fg:x="22860" fg:w="4"/><text x="58.7424%" y="47.50"></text></g><g><title>finish_task_switch.isra.0 (19 samples, 0.05%)</title><rect x="58.4745%" y="117" width="0.0486%" height="15" fill="rgb(236,151,0)" fg:x="22853" fg:w="19"/><text x="58.7245%" y="127.50"></text></g><g><title>raw_spin_rq_unlock (5 samples, 0.01%)</title><rect x="58.5103%" y="101" width="0.0128%" height="15" fill="rgb(209,168,3)" fg:x="22867" fg:w="5"/><text x="58.7603%" y="111.50"></text></g><g><title>pick_next_task_fair (5 samples, 0.01%)</title><rect x="58.5257%" y="101" width="0.0128%" height="15" fill="rgb(208,129,28)" fg:x="22873" fg:w="5"/><text x="58.7757%" y="111.50"></text></g><g><title>pick_next_task (10 samples, 0.03%)</title><rect x="58.5231%" y="117" width="0.0256%" height="15" fill="rgb(229,78,22)" fg:x="22872" fg:w="10"/><text x="58.7731%" y="127.50"></text></g><g><title>put_prev_task_fair (4 samples, 0.01%)</title><rect x="58.5385%" y="101" width="0.0102%" height="15" fill="rgb(228,187,13)" fg:x="22878" fg:w="4"/><text x="58.7885%" y="111.50"></text></g><g><title>prepare_task_switch (16 samples, 0.04%)</title><rect x="58.5513%" y="117" width="0.0409%" height="15" fill="rgb(240,119,24)" fg:x="22883" fg:w="16"/><text x="58.8013%" y="127.50"></text></g><g><title>__perf_event_task_sched_out (5 samples, 0.01%)</title><rect x="58.5794%" y="101" width="0.0128%" height="15" fill="rgb(209,194,42)" fg:x="22894" fg:w="5"/><text x="58.8294%" y="111.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="58.5820%" y="85" width="0.0102%" height="15" fill="rgb(247,200,46)" fg:x="22895" fg:w="4"/><text x="58.8320%" y="95.50"></text></g><g><title>psi_group_change (22 samples, 0.06%)</title><rect x="58.6280%" y="101" width="0.0563%" height="15" fill="rgb(218,76,16)" fg:x="22913" fg:w="22"/><text x="58.8780%" y="111.50"></text></g><g><title>psi_task_switch (35 samples, 0.09%)</title><rect x="58.5973%" y="117" width="0.0896%" height="15" fill="rgb(225,21,48)" fg:x="22901" fg:w="35"/><text x="58.8473%" y="127.50"></text></g><g><title>futex_wait_queue (143 samples, 0.37%)</title><rect x="58.3338%" y="165" width="0.3659%" height="15" fill="rgb(239,223,50)" fg:x="22798" fg:w="143"/><text x="58.5838%" y="175.50"></text></g><g><title>schedule (136 samples, 0.35%)</title><rect x="58.3517%" y="149" width="0.3480%" height="15" fill="rgb(244,45,21)" fg:x="22805" fg:w="136"/><text x="58.6017%" y="159.50"></text></g><g><title>__schedule (130 samples, 0.33%)</title><rect x="58.3670%" y="133" width="0.3326%" height="15" fill="rgb(232,33,43)" fg:x="22811" fg:w="130"/><text x="58.6170%" y="143.50"></text></g><g><title>__get_user_nocheck_4 (8 samples, 0.02%)</title><rect x="58.7125%" y="149" width="0.0205%" height="15" fill="rgb(209,8,3)" fg:x="22946" fg:w="8"/><text x="58.9625%" y="159.50"></text></g><g><title>_raw_spin_lock (6 samples, 0.02%)</title><rect x="58.7329%" y="149" width="0.0154%" height="15" fill="rgb(214,25,53)" fg:x="22954" fg:w="6"/><text x="58.9829%" y="159.50"></text></g><g><title>futex_q_lock (8 samples, 0.02%)</title><rect x="58.7508%" y="149" width="0.0205%" height="15" fill="rgb(254,186,54)" fg:x="22961" fg:w="8"/><text x="59.0008%" y="159.50"></text></g><g><title>futex_wait (192 samples, 0.49%)</title><rect x="58.2851%" y="181" width="0.4913%" height="15" fill="rgb(208,174,49)" fg:x="22779" fg:w="192"/><text x="58.5351%" y="191.50"></text></g><g><title>futex_wait_setup (30 samples, 0.08%)</title><rect x="58.6997%" y="165" width="0.0768%" height="15" fill="rgb(233,191,51)" fg:x="22941" fg:w="30"/><text x="58.9497%" y="175.50"></text></g><g><title>__x64_sys_futex (201 samples, 0.51%)</title><rect x="58.2647%" y="213" width="0.5143%" height="15" fill="rgb(222,134,10)" fg:x="22771" fg:w="201"/><text x="58.5147%" y="223.50"></text></g><g><title>do_futex (200 samples, 0.51%)</title><rect x="58.2672%" y="197" width="0.5117%" height="15" fill="rgb(230,226,20)" fg:x="22772" fg:w="200"/><text x="58.5172%" y="207.50"></text></g><g><title>__rseq_handle_notify_resume (7 samples, 0.02%)</title><rect x="58.8122%" y="165" width="0.0179%" height="15" fill="rgb(251,111,25)" fg:x="22985" fg:w="7"/><text x="59.0622%" y="175.50"></text></g><g><title>rseq_update_cpu_node_id (5 samples, 0.01%)</title><rect x="58.8174%" y="149" width="0.0128%" height="15" fill="rgb(224,40,46)" fg:x="22987" fg:w="5"/><text x="59.0674%" y="159.50"></text></g><g><title>exit_to_user_mode_loop (12 samples, 0.03%)</title><rect x="58.8020%" y="181" width="0.0307%" height="15" fill="rgb(236,108,47)" fg:x="22981" fg:w="12"/><text x="59.0520%" y="191.50"></text></g><g><title>exit_to_user_mode_prepare (19 samples, 0.05%)</title><rect x="58.7892%" y="197" width="0.0486%" height="15" fill="rgb(234,93,0)" fg:x="22976" fg:w="19"/><text x="59.0392%" y="207.50"></text></g><g><title>do_syscall_64 (227 samples, 0.58%)</title><rect x="58.2596%" y="229" width="0.5808%" height="15" fill="rgb(224,213,32)" fg:x="22769" fg:w="227"/><text x="58.5096%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (22 samples, 0.06%)</title><rect x="58.7841%" y="213" width="0.0563%" height="15" fill="rgb(251,11,48)" fg:x="22974" fg:w="22"/><text x="59.0341%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (233 samples, 0.60%)</title><rect x="58.2468%" y="245" width="0.5962%" height="15" fill="rgb(236,173,5)" fg:x="22764" fg:w="233"/><text x="58.4968%" y="255.50"></text></g><g><title>__lll_lock_wait_private (283 samples, 0.72%)</title><rect x="58.1214%" y="261" width="0.7241%" height="15" fill="rgb(230,95,12)" fg:x="22715" fg:w="283"/><text x="58.3714%" y="271.50"></text></g><g><title>[libc.so.6] (759 samples, 1.94%)</title><rect x="56.9060%" y="277" width="1.9421%" height="15" fill="rgb(232,209,1)" fg:x="22240" fg:w="759"/><text x="57.1560%" y="287.50">[..</text></g><g><title>__entry_text_start (8 samples, 0.02%)</title><rect x="58.8711%" y="261" width="0.0205%" height="15" fill="rgb(232,6,1)" fg:x="23008" fg:w="8"/><text x="59.1211%" y="271.50"></text></g><g><title>futex_hash (7 samples, 0.02%)</title><rect x="58.9171%" y="197" width="0.0179%" height="15" fill="rgb(210,224,50)" fg:x="23026" fg:w="7"/><text x="59.1671%" y="207.50"></text></g><g><title>_raw_spin_lock (12 samples, 0.03%)</title><rect x="59.0297%" y="181" width="0.0307%" height="15" fill="rgb(228,127,35)" fg:x="23070" fg:w="12"/><text x="59.2797%" y="191.50"></text></g><g><title>native_queued_spin_lock_slowpath (12 samples, 0.03%)</title><rect x="59.0297%" y="165" width="0.0307%" height="15" fill="rgb(245,102,45)" fg:x="23070" fg:w="12"/><text x="59.2797%" y="175.50"></text></g><g><title>__x64_sys_futex (65 samples, 0.17%)</title><rect x="58.8992%" y="229" width="0.1663%" height="15" fill="rgb(214,1,49)" fg:x="23019" fg:w="65"/><text x="59.1492%" y="239.50"></text></g><g><title>do_futex (61 samples, 0.16%)</title><rect x="58.9095%" y="213" width="0.1561%" height="15" fill="rgb(226,163,40)" fg:x="23023" fg:w="61"/><text x="59.1595%" y="223.50"></text></g><g><title>futex_wake (51 samples, 0.13%)</title><rect x="58.9351%" y="197" width="0.1305%" height="15" fill="rgb(239,212,28)" fg:x="23033" fg:w="51"/><text x="59.1851%" y="207.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (78 samples, 0.20%)</title><rect x="58.8916%" y="261" width="0.1996%" height="15" fill="rgb(220,20,13)" fg:x="23016" fg:w="78"/><text x="59.1416%" y="271.50"></text></g><g><title>do_syscall_64 (77 samples, 0.20%)</title><rect x="58.8941%" y="245" width="0.1970%" height="15" fill="rgb(210,164,35)" fg:x="23017" fg:w="77"/><text x="59.1441%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (6 samples, 0.02%)</title><rect x="59.0758%" y="229" width="0.0154%" height="15" fill="rgb(248,109,41)" fg:x="23088" fg:w="6"/><text x="59.3258%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (6 samples, 0.02%)</title><rect x="59.0758%" y="213" width="0.0154%" height="15" fill="rgb(238,23,50)" fg:x="23088" fg:w="6"/><text x="59.3258%" y="223.50"></text></g><g><title>alloc::alloc::dealloc (903 samples, 2.31%)</title><rect x="56.7832%" y="309" width="2.3105%" height="15" fill="rgb(211,48,49)" fg:x="22192" fg:w="903"/><text x="57.0332%" y="319.50">a..</text></g><g><title>cfree (896 samples, 2.29%)</title><rect x="56.8011%" y="293" width="2.2926%" height="15" fill="rgb(223,36,21)" fg:x="22199" fg:w="896"/><text x="57.0511%" y="303.50">c..</text></g><g><title>__lll_lock_wake_private (96 samples, 0.25%)</title><rect x="58.8481%" y="277" width="0.2456%" height="15" fill="rgb(207,123,46)" fg:x="22999" fg:w="96"/><text x="59.0981%" y="287.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (906 samples, 2.32%)</title><rect x="56.7832%" y="325" width="2.3182%" height="15" fill="rgb(240,218,32)" fg:x="22192" fg:w="906"/><text x="57.0332%" y="335.50">&lt;..</text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (914 samples, 2.34%)</title><rect x="56.7755%" y="469" width="2.3387%" height="15" fill="rgb(252,5,43)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="479.50">c..</text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (914 samples, 2.34%)</title><rect x="56.7755%" y="453" width="2.3387%" height="15" fill="rgb(252,84,19)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="463.50">&lt;..</text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (914 samples, 2.34%)</title><rect x="56.7755%" y="437" width="2.3387%" height="15" fill="rgb(243,152,39)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="447.50">a..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (914 samples, 2.34%)</title><rect x="56.7755%" y="421" width="2.3387%" height="15" fill="rgb(234,160,15)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="431.50">a..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (914 samples, 2.34%)</title><rect x="56.7755%" y="405" width="2.3387%" height="15" fill="rgb(237,34,20)" fg:x="22189" fg:w="914"/><text x="57.0255%" y="415.50">a..</text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (913 samples, 2.34%)</title><rect x="56.7781%" y="389" width="2.3361%" height="15" fill="rgb(229,97,13)" fg:x="22190" fg:w="913"/><text x="57.0281%" y="399.50">c..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (911 samples, 2.33%)</title><rect x="56.7832%" y="373" width="2.3310%" height="15" fill="rgb(234,71,50)" fg:x="22192" fg:w="911"/><text x="57.0332%" y="383.50">c..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (911 samples, 2.33%)</title><rect x="56.7832%" y="357" width="2.3310%" height="15" fill="rgb(253,155,4)" fg:x="22192" fg:w="911"/><text x="57.0332%" y="367.50">c..</text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (911 samples, 2.33%)</title><rect x="56.7832%" y="341" width="2.3310%" height="15" fill="rgb(222,185,37)" fg:x="22192" fg:w="911"/><text x="57.0332%" y="351.50">&lt;..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::current_memory (5 samples, 0.01%)</title><rect x="59.1014%" y="325" width="0.0128%" height="15" fill="rgb(251,177,13)" fg:x="23098" fg:w="5"/><text x="59.3514%" y="335.50"></text></g><g><title>std::sync::poison::Flag::done (9 samples, 0.02%)</title><rect x="59.1142%" y="437" width="0.0230%" height="15" fill="rgb(250,179,40)" fg:x="23103" fg:w="9"/><text x="59.3642%" y="447.50"></text></g><g><title>std::thread::panicking (9 samples, 0.02%)</title><rect x="59.1142%" y="421" width="0.0230%" height="15" fill="rgb(242,44,2)" fg:x="23103" fg:w="9"/><text x="59.3642%" y="431.50"></text></g><g><title>std::panicking::panicking (9 samples, 0.02%)</title><rect x="59.1142%" y="405" width="0.0230%" height="15" fill="rgb(216,177,13)" fg:x="23103" fg:w="9"/><text x="59.3642%" y="415.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (9 samples, 0.02%)</title><rect x="59.1142%" y="389" width="0.0230%" height="15" fill="rgb(216,106,43)" fg:x="23103" fg:w="9"/><text x="59.3642%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (5 samples, 0.01%)</title><rect x="59.1244%" y="373" width="0.0128%" height="15" fill="rgb(216,183,2)" fg:x="23107" fg:w="5"/><text x="59.3744%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="59.1244%" y="357" width="0.0128%" height="15" fill="rgb(249,75,3)" fg:x="23107" fg:w="5"/><text x="59.3744%" y="367.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (71 samples, 0.18%)</title><rect x="59.1142%" y="469" width="0.1817%" height="15" fill="rgb(219,67,39)" fg:x="23103" fg:w="71"/><text x="59.3642%" y="479.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (71 samples, 0.18%)</title><rect x="59.1142%" y="453" width="0.1817%" height="15" fill="rgb(253,228,2)" fg:x="23103" fg:w="71"/><text x="59.3642%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (62 samples, 0.16%)</title><rect x="59.1372%" y="437" width="0.1586%" height="15" fill="rgb(235,138,27)" fg:x="23112" fg:w="62"/><text x="59.3872%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (61 samples, 0.16%)</title><rect x="59.1398%" y="421" width="0.1561%" height="15" fill="rgb(236,97,51)" fg:x="23113" fg:w="61"/><text x="59.3898%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_swap (61 samples, 0.16%)</title><rect x="59.1398%" y="405" width="0.1561%" height="15" fill="rgb(240,80,30)" fg:x="23113" fg:w="61"/><text x="59.3898%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;std::collections::hash::map::HashMap&lt;core::num::nonzero::NonZeroU32,alloc::sync::Weak&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt;&gt;&gt; (58 samples, 0.15%)</title><rect x="59.2958%" y="469" width="0.1484%" height="15" fill="rgb(230,178,19)" fg:x="23174" fg:w="58"/><text x="59.5458%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (58 samples, 0.15%)</title><rect x="59.2958%" y="453" width="0.1484%" height="15" fill="rgb(210,190,27)" fg:x="23174" fg:w="58"/><text x="59.5458%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (58 samples, 0.15%)</title><rect x="59.2958%" y="437" width="0.1484%" height="15" fill="rgb(222,107,31)" fg:x="23174" fg:w="58"/><text x="59.5458%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (53 samples, 0.14%)</title><rect x="59.3086%" y="421" width="0.1356%" height="15" fill="rgb(216,127,34)" fg:x="23179" fg:w="53"/><text x="59.5586%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (53 samples, 0.14%)</title><rect x="59.3086%" y="405" width="0.1356%" height="15" fill="rgb(234,116,52)" fg:x="23179" fg:w="53"/><text x="59.5586%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (48 samples, 0.12%)</title><rect x="59.4442%" y="469" width="0.1228%" height="15" fill="rgb(222,124,15)" fg:x="23232" fg:w="48"/><text x="59.6942%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (48 samples, 0.12%)</title><rect x="59.4442%" y="453" width="0.1228%" height="15" fill="rgb(231,179,28)" fg:x="23232" fg:w="48"/><text x="59.6942%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (48 samples, 0.12%)</title><rect x="59.4442%" y="437" width="0.1228%" height="15" fill="rgb(226,93,45)" fg:x="23232" fg:w="48"/><text x="59.6942%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (44 samples, 0.11%)</title><rect x="59.4545%" y="421" width="0.1126%" height="15" fill="rgb(215,8,51)" fg:x="23236" fg:w="44"/><text x="59.7045%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (44 samples, 0.11%)</title><rect x="59.4545%" y="405" width="0.1126%" height="15" fill="rgb(223,106,5)" fg:x="23236" fg:w="44"/><text x="59.7045%" y="415.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (6 samples, 0.02%)</title><rect x="59.6131%" y="325" width="0.0154%" height="15" fill="rgb(250,191,5)" fg:x="23298" fg:w="6"/><text x="59.8631%" y="335.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::c_rounds (11 samples, 0.03%)</title><rect x="59.6054%" y="341" width="0.0281%" height="15" fill="rgb(242,132,44)" fg:x="23295" fg:w="11"/><text x="59.8554%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (11 samples, 0.03%)</title><rect x="59.6515%" y="325" width="0.0281%" height="15" fill="rgb(251,152,29)" fg:x="23313" fg:w="11"/><text x="59.9015%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="59.5799%" y="389" width="0.1305%" height="15" fill="rgb(218,179,5)" fg:x="23285" fg:w="51"/><text x="59.8299%" y="399.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="59.5799%" y="373" width="0.1305%" height="15" fill="rgb(227,67,19)" fg:x="23285" fg:w="51"/><text x="59.8299%" y="383.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::finish (51 samples, 0.13%)</title><rect x="59.5799%" y="357" width="0.1305%" height="15" fill="rgb(233,119,31)" fg:x="23285" fg:w="51"/><text x="59.8299%" y="367.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::d_rounds (30 samples, 0.08%)</title><rect x="59.6336%" y="341" width="0.0768%" height="15" fill="rgb(241,120,22)" fg:x="23306" fg:w="30"/><text x="59.8836%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (12 samples, 0.03%)</title><rect x="59.6796%" y="325" width="0.0307%" height="15" fill="rgb(224,102,30)" fg:x="23324" fg:w="12"/><text x="59.9296%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::RandomState as core::hash::BuildHasher&gt;::build_hasher (5 samples, 0.01%)</title><rect x="59.7104%" y="389" width="0.0128%" height="15" fill="rgb(210,164,37)" fg:x="23336" fg:w="5"/><text x="59.9604%" y="399.50"></text></g><g><title>hashbrown::map::make_hash (76 samples, 0.19%)</title><rect x="59.5722%" y="421" width="0.1945%" height="15" fill="rgb(226,191,16)" fg:x="23282" fg:w="76"/><text x="59.8222%" y="431.50"></text></g><g><title>core::hash::BuildHasher::hash_one (76 samples, 0.19%)</title><rect x="59.5722%" y="405" width="0.1945%" height="15" fill="rgb(214,40,45)" fg:x="23282" fg:w="76"/><text x="59.8222%" y="415.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (17 samples, 0.04%)</title><rect x="59.7231%" y="389" width="0.0435%" height="15" fill="rgb(244,29,26)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="399.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (17 samples, 0.04%)</title><rect x="59.7231%" y="373" width="0.0435%" height="15" fill="rgb(216,16,5)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="383.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for u32&gt;::hash (17 samples, 0.04%)</title><rect x="59.7231%" y="357" width="0.0435%" height="15" fill="rgb(249,76,35)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="367.50"></text></g><g><title>core::hash::Hasher::write_u32 (17 samples, 0.04%)</title><rect x="59.7231%" y="341" width="0.0435%" height="15" fill="rgb(207,11,44)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="351.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::write (17 samples, 0.04%)</title><rect x="59.7231%" y="325" width="0.0435%" height="15" fill="rgb(228,190,49)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="335.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::write (17 samples, 0.04%)</title><rect x="59.7231%" y="309" width="0.0435%" height="15" fill="rgb(214,173,12)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="319.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::write (17 samples, 0.04%)</title><rect x="59.7231%" y="293" width="0.0435%" height="15" fill="rgb(218,26,35)" fg:x="23341" fg:w="17"/><text x="59.9731%" y="303.50"></text></g><g><title>core::hash::sip::u8to64_le (7 samples, 0.02%)</title><rect x="59.7487%" y="277" width="0.0179%" height="15" fill="rgb(220,200,19)" fg:x="23351" fg:w="7"/><text x="59.9987%" y="287.50"></text></g><g><title>&lt;hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator&gt;::next (9 samples, 0.02%)</title><rect x="59.7820%" y="373" width="0.0230%" height="15" fill="rgb(239,95,49)" fg:x="23364" fg:w="9"/><text x="60.0320%" y="383.50"></text></g><g><title>hashbrown::raw::bitmask::BitMask::lowest_set_bit (5 samples, 0.01%)</title><rect x="59.7922%" y="357" width="0.0128%" height="15" fill="rgb(235,85,53)" fg:x="23368" fg:w="5"/><text x="60.0422%" y="367.50"></text></g><g><title>hashbrown::map::equivalent_key::_{{closure}} (7 samples, 0.02%)</title><rect x="59.8050%" y="357" width="0.0179%" height="15" fill="rgb(233,133,31)" fg:x="23373" fg:w="7"/><text x="60.0550%" y="367.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::cmp::PartialEq&gt;::eq (7 samples, 0.02%)</title><rect x="59.8050%" y="341" width="0.0179%" height="15" fill="rgb(218,25,20)" fg:x="23373" fg:w="7"/><text x="60.0550%" y="351.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find::_{{closure}} (11 samples, 0.03%)</title><rect x="59.8050%" y="373" width="0.0281%" height="15" fill="rgb(252,210,38)" fg:x="23373" fg:w="11"/><text x="60.0550%" y="383.50"></text></g><g><title>hashbrown::raw::Bucket&lt;T&gt;::as_ref (4 samples, 0.01%)</title><rect x="59.8229%" y="357" width="0.0102%" height="15" fill="rgb(242,134,21)" fg:x="23380" fg:w="4"/><text x="60.0729%" y="367.50"></text></g><g><title>hashbrown::raw::Bucket&lt;T&gt;::as_ptr (4 samples, 0.01%)</title><rect x="59.8229%" y="341" width="0.0102%" height="15" fill="rgb(213,28,48)" fg:x="23380" fg:w="4"/><text x="60.0729%" y="351.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::sub (4 samples, 0.01%)</title><rect x="59.8229%" y="325" width="0.0102%" height="15" fill="rgb(250,196,2)" fg:x="23380" fg:w="4"/><text x="60.0729%" y="335.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::offset (4 samples, 0.01%)</title><rect x="59.8229%" y="309" width="0.0102%" height="15" fill="rgb(227,5,17)" fg:x="23380" fg:w="4"/><text x="60.0729%" y="319.50"></text></g><g><title>hashbrown::raw::h2 (10 samples, 0.03%)</title><rect x="59.8332%" y="373" width="0.0256%" height="15" fill="rgb(221,226,24)" fg:x="23384" fg:w="10"/><text x="60.0832%" y="383.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (119 samples, 0.30%)</title><rect x="59.5722%" y="437" width="0.3045%" height="15" fill="rgb(211,5,48)" fg:x="23282" fg:w="119"/><text x="59.8222%" y="447.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::get (43 samples, 0.11%)</title><rect x="59.7666%" y="421" width="0.1100%" height="15" fill="rgb(219,150,6)" fg:x="23358" fg:w="43"/><text x="60.0166%" y="431.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find (43 samples, 0.11%)</title><rect x="59.7666%" y="405" width="0.1100%" height="15" fill="rgb(251,46,16)" fg:x="23358" fg:w="43"/><text x="60.0166%" y="415.50"></text></g><g><title>hashbrown::raw::RawTableInner&lt;A&gt;::find_inner (43 samples, 0.11%)</title><rect x="59.7666%" y="389" width="0.1100%" height="15" fill="rgb(220,204,40)" fg:x="23358" fg:w="43"/><text x="60.0166%" y="399.50"></text></g><g><title>hashbrown::raw::sse2::Group::match_byte (4 samples, 0.01%)</title><rect x="59.8664%" y="373" width="0.0102%" height="15" fill="rgb(211,85,2)" fg:x="23397" fg:w="4"/><text x="60.1164%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_movemask_epi8 (4 samples, 0.01%)</title><rect x="59.8664%" y="357" width="0.0102%" height="15" fill="rgb(229,17,7)" fg:x="23397" fg:w="4"/><text x="60.1164%" y="367.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (122 samples, 0.31%)</title><rect x="59.5722%" y="469" width="0.3122%" height="15" fill="rgb(239,72,28)" fg:x="23282" fg:w="122"/><text x="59.8222%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (122 samples, 0.31%)</title><rect x="59.5722%" y="453" width="0.3122%" height="15" fill="rgb(230,47,54)" fg:x="23282" fg:w="122"/><text x="59.8222%" y="463.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (8 samples, 0.02%)</title><rect x="59.8895%" y="453" width="0.0205%" height="15" fill="rgb(214,50,8)" fg:x="23406" fg:w="8"/><text x="60.1395%" y="463.50"></text></g><g><title>std::sync::poison::Flag::guard (5 samples, 0.01%)</title><rect x="59.8971%" y="437" width="0.0128%" height="15" fill="rgb(216,198,43)" fg:x="23409" fg:w="5"/><text x="60.1471%" y="447.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (47 samples, 0.12%)</title><rect x="59.8843%" y="469" width="0.1203%" height="15" fill="rgb(234,20,35)" fg:x="23404" fg:w="47"/><text x="60.1343%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (37 samples, 0.09%)</title><rect x="59.9099%" y="453" width="0.0947%" height="15" fill="rgb(254,45,19)" fg:x="23414" fg:w="37"/><text x="60.1599%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (37 samples, 0.09%)</title><rect x="59.9099%" y="437" width="0.0947%" height="15" fill="rgb(219,14,44)" fg:x="23414" fg:w="37"/><text x="60.1599%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (37 samples, 0.09%)</title><rect x="59.9099%" y="421" width="0.0947%" height="15" fill="rgb(217,220,26)" fg:x="23414" fg:w="37"/><text x="60.1599%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (108 samples, 0.28%)</title><rect x="60.0404%" y="437" width="0.2763%" height="15" fill="rgb(213,158,28)" fg:x="23465" fg:w="108"/><text x="60.2904%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (108 samples, 0.28%)</title><rect x="60.0404%" y="421" width="0.2763%" height="15" fill="rgb(252,51,52)" fg:x="23465" fg:w="108"/><text x="60.2904%" y="431.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (129 samples, 0.33%)</title><rect x="60.0046%" y="469" width="0.3301%" height="15" fill="rgb(246,89,16)" fg:x="23451" fg:w="129"/><text x="60.2546%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (129 samples, 0.33%)</title><rect x="60.0046%" y="453" width="0.3301%" height="15" fill="rgb(216,158,49)" fg:x="23451" fg:w="129"/><text x="60.2546%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::is_read_lockable (7 samples, 0.02%)</title><rect x="60.3168%" y="437" width="0.0179%" height="15" fill="rgb(236,107,19)" fg:x="23573" fg:w="7"/><text x="60.5668%" y="447.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::check (11 samples, 0.03%)</title><rect x="60.3347%" y="469" width="0.0281%" height="15" fill="rgb(228,185,30)" fg:x="23580" fg:w="11"/><text x="60.5847%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicU64::load (6 samples, 0.02%)</title><rect x="60.3475%" y="453" width="0.0154%" height="15" fill="rgb(246,134,8)" fg:x="23585" fg:w="6"/><text x="60.5975%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="60.3475%" y="437" width="0.0154%" height="15" fill="rgb(214,143,50)" fg:x="23585" fg:w="6"/><text x="60.5975%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::push (19 samples, 0.05%)</title><rect x="60.4217%" y="453" width="0.0486%" height="15" fill="rgb(228,75,8)" fg:x="23614" fg:w="19"/><text x="60.6717%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push (19 samples, 0.05%)</title><rect x="60.4217%" y="437" width="0.0486%" height="15" fill="rgb(207,175,4)" fg:x="23614" fg:w="19"/><text x="60.6717%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::try_push (19 samples, 0.05%)</title><rect x="60.4217%" y="421" width="0.0486%" height="15" fill="rgb(205,108,24)" fg:x="23614" fg:w="19"/><text x="60.6717%" y="431.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push_unchecked (13 samples, 0.03%)</title><rect x="60.4370%" y="405" width="0.0333%" height="15" fill="rgb(244,120,49)" fg:x="23620" fg:w="13"/><text x="60.6870%" y="415.50"></text></g><g><title>core::ptr::write (12 samples, 0.03%)</title><rect x="60.4396%" y="389" width="0.0307%" height="15" fill="rgb(223,47,38)" fg:x="23621" fg:w="12"/><text x="60.6896%" y="399.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init_read (4 samples, 0.01%)</title><rect x="60.4780%" y="453" width="0.0102%" height="15" fill="rgb(229,179,11)" fg:x="23636" fg:w="4"/><text x="60.7280%" y="463.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::read (4 samples, 0.01%)</title><rect x="60.4780%" y="437" width="0.0102%" height="15" fill="rgb(231,122,1)" fg:x="23636" fg:w="4"/><text x="60.7280%" y="447.50"></text></g><g><title>core::ptr::read (4 samples, 0.01%)</title><rect x="60.4780%" y="421" width="0.0102%" height="15" fill="rgb(245,119,9)" fg:x="23636" fg:w="4"/><text x="60.7280%" y="431.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init (4 samples, 0.01%)</title><rect x="60.4780%" y="405" width="0.0102%" height="15" fill="rgb(241,163,25)" fg:x="23636" fg:w="4"/><text x="60.7280%" y="415.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::write (4 samples, 0.01%)</title><rect x="60.4882%" y="453" width="0.0102%" height="15" fill="rgb(217,214,3)" fg:x="23640" fg:w="4"/><text x="60.7382%" y="463.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (5 samples, 0.01%)</title><rect x="60.5061%" y="453" width="0.0128%" height="15" fill="rgb(240,86,28)" fg:x="23647" fg:w="5"/><text x="60.7561%" y="463.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (62 samples, 0.16%)</title><rect x="60.3628%" y="469" width="0.1586%" height="15" fill="rgb(215,47,9)" fg:x="23591" fg:w="62"/><text x="60.6128%" y="479.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (26 samples, 0.07%)</title><rect x="60.5240%" y="453" width="0.0665%" height="15" fill="rgb(252,25,45)" fg:x="23654" fg:w="26"/><text x="60.7740%" y="463.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (26 samples, 0.07%)</title><rect x="60.5240%" y="437" width="0.0665%" height="15" fill="rgb(251,164,9)" fg:x="23654" fg:w="26"/><text x="60.7740%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (26 samples, 0.07%)</title><rect x="60.5240%" y="421" width="0.0665%" height="15" fill="rgb(233,194,0)" fg:x="23654" fg:w="26"/><text x="60.7740%" y="431.50"></text></g><g><title>zssp::zeta::from_nonce (31 samples, 0.08%)</title><rect x="60.5215%" y="469" width="0.0793%" height="15" fill="rgb(249,111,24)" fg:x="23653" fg:w="31"/><text x="60.7715%" y="479.50"></text></g><g><title>core::num::&lt;impl u64&gt;::from_be_bytes (4 samples, 0.01%)</title><rect x="60.5906%" y="453" width="0.0102%" height="15" fill="rgb(250,223,3)" fg:x="23680" fg:w="4"/><text x="60.8406%" y="463.50"></text></g><g><title>core::num::&lt;impl u64&gt;::from_be (4 samples, 0.01%)</title><rect x="60.5906%" y="437" width="0.0102%" height="15" fill="rgb(236,178,37)" fg:x="23680" fg:w="4"/><text x="60.8406%" y="447.50"></text></g><g><title>core::num::&lt;impl u64&gt;::swap_bytes (4 samples, 0.01%)</title><rect x="60.5906%" y="421" width="0.0102%" height="15" fill="rgb(241,158,50)" fg:x="23680" fg:w="4"/><text x="60.8406%" y="431.50"></text></g><g><title>&lt;core::slice::iter::IterMut&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::next (9 samples, 0.02%)</title><rect x="60.6417%" y="453" width="0.0230%" height="15" fill="rgb(213,121,41)" fg:x="23700" fg:w="9"/><text x="60.8917%" y="463.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (55 samples, 0.14%)</title><rect x="60.6648%" y="453" width="0.1407%" height="15" fill="rgb(240,92,3)" fg:x="23709" fg:w="55"/><text x="60.9148%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (55 samples, 0.14%)</title><rect x="60.6648%" y="437" width="0.1407%" height="15" fill="rgb(205,123,3)" fg:x="23709" fg:w="55"/><text x="60.9148%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (53 samples, 0.14%)</title><rect x="60.6699%" y="421" width="0.1356%" height="15" fill="rgb(205,97,47)" fg:x="23711" fg:w="53"/><text x="60.9199%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (53 samples, 0.14%)</title><rect x="60.6699%" y="405" width="0.1356%" height="15" fill="rgb(247,152,14)" fg:x="23711" fg:w="53"/><text x="60.9199%" y="415.50"></text></g><g><title>[libcrypto.so.3] (103 samples, 0.26%)</title><rect x="61.5552%" y="341" width="0.2635%" height="15" fill="rgb(248,195,53)" fg:x="24057" fg:w="103"/><text x="61.8052%" y="351.50"></text></g><g><title>CRYPTO_gcm128_decrypt (234 samples, 0.60%)</title><rect x="61.2328%" y="357" width="0.5987%" height="15" fill="rgb(226,201,16)" fg:x="23931" fg:w="234"/><text x="61.4828%" y="367.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="61.8187%" y="341" width="0.0128%" height="15" fill="rgb(205,98,0)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="61.8187%" y="325" width="0.0128%" height="15" fill="rgb(214,191,48)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="335.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="61.8187%" y="309" width="0.0128%" height="15" fill="rgb(237,112,39)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="61.8187%" y="293" width="0.0128%" height="15" fill="rgb(247,203,27)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="61.8187%" y="277" width="0.0128%" height="15" fill="rgb(235,124,28)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="61.8187%" y="261" width="0.0128%" height="15" fill="rgb(208,207,46)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="61.8187%" y="245" width="0.0128%" height="15" fill="rgb(234,176,4)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="61.8187%" y="229" width="0.0128%" height="15" fill="rgb(230,133,28)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="239.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="61.8187%" y="213" width="0.0128%" height="15" fill="rgb(211,137,40)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="61.8187%" y="197" width="0.0128%" height="15" fill="rgb(254,35,13)" fg:x="24160" fg:w="5"/><text x="62.0687%" y="207.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="61.8213%" y="181" width="0.0102%" height="15" fill="rgb(225,49,51)" fg:x="24161" fg:w="4"/><text x="62.0713%" y="191.50"></text></g><g><title>[libcrypto.so.3] (17 samples, 0.04%)</title><rect x="62.9420%" y="325" width="0.0435%" height="15" fill="rgb(251,10,15)" fg:x="24599" fg:w="17"/><text x="63.1920%" y="335.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (452 samples, 1.16%)</title><rect x="61.8315%" y="357" width="1.1565%" height="15" fill="rgb(228,207,15)" fg:x="24165" fg:w="452"/><text x="62.0815%" y="367.50"></text></g><g><title>[libcrypto.so.3] (355 samples, 0.91%)</title><rect x="62.0797%" y="341" width="0.9083%" height="15" fill="rgb(241,99,19)" fg:x="24262" fg:w="355"/><text x="62.3297%" y="351.50"></text></g><g><title>CRYPTO_gcm128_setiv (15 samples, 0.04%)</title><rect x="62.9881%" y="357" width="0.0384%" height="15" fill="rgb(207,104,49)" fg:x="24617" fg:w="15"/><text x="63.2381%" y="367.50"></text></g><g><title>[libcrypto.so.3] (14 samples, 0.04%)</title><rect x="62.9906%" y="341" width="0.0358%" height="15" fill="rgb(234,99,18)" fg:x="24618" fg:w="14"/><text x="63.2406%" y="351.50"></text></g><g><title>asm_sysvec_apic_timer_interrupt (5 samples, 0.01%)</title><rect x="71.7619%" y="325" width="0.0128%" height="15" fill="rgb(213,191,49)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="335.50"></text></g><g><title>sysvec_apic_timer_interrupt (5 samples, 0.01%)</title><rect x="71.7619%" y="309" width="0.0128%" height="15" fill="rgb(210,226,19)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="71.7619%" y="293" width="0.0128%" height="15" fill="rgb(229,97,18)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="71.7619%" y="277" width="0.0128%" height="15" fill="rgb(211,167,15)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="71.7619%" y="261" width="0.0128%" height="15" fill="rgb(210,169,34)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="71.7619%" y="245" width="0.0128%" height="15" fill="rgb(241,121,31)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="71.7619%" y="229" width="0.0128%" height="15" fill="rgb(232,40,11)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="71.7619%" y="213" width="0.0128%" height="15" fill="rgb(205,86,26)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="71.7619%" y="197" width="0.0128%" height="15" fill="rgb(231,126,28)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="71.7619%" y="181" width="0.0128%" height="15" fill="rgb(219,221,18)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="191.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="71.7619%" y="165" width="0.0128%" height="15" fill="rgb(211,40,0)" fg:x="28046" fg:w="5"/><text x="72.0119%" y="175.50"></text></g><g><title>__perf_event_task_sched_in (9 samples, 0.02%)</title><rect x="71.7747%" y="181" width="0.0230%" height="15" fill="rgb(239,85,43)" fg:x="28051" fg:w="9"/><text x="72.0247%" y="191.50"></text></g><g><title>perf_ctx_enable (9 samples, 0.02%)</title><rect x="71.7747%" y="165" width="0.0230%" height="15" fill="rgb(231,55,21)" fg:x="28051" fg:w="9"/><text x="72.0247%" y="175.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (4,297 samples, 10.99%)</title><rect x="60.8055%" y="453" width="10.9948%" height="15" fill="rgb(225,184,43)" fg:x="23764" fg:w="4297"/><text x="61.0555%" y="463.50">&lt;zssp::crypto_im..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4,297 samples, 10.99%)</title><rect x="60.8055%" y="437" width="10.9948%" height="15" fill="rgb(251,158,41)" fg:x="23764" fg:w="4297"/><text x="61.0555%" y="447.50">zssp::crypto_imp..</text></g><g><title>EVP_DecryptUpdate (4,294 samples, 10.99%)</title><rect x="60.8132%" y="421" width="10.9872%" height="15" fill="rgb(234,159,37)" fg:x="23767" fg:w="4294"/><text x="61.0632%" y="431.50">EVP_DecryptUpdate</text></g><g><title>[libcrypto.so.3] (4,195 samples, 10.73%)</title><rect x="61.0665%" y="405" width="10.7338%" height="15" fill="rgb(216,204,22)" fg:x="23866" fg:w="4195"/><text x="61.3165%" y="415.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,187 samples, 10.71%)</title><rect x="61.0869%" y="389" width="10.7134%" height="15" fill="rgb(214,17,3)" fg:x="23874" fg:w="4187"/><text x="61.3369%" y="399.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,169 samples, 10.67%)</title><rect x="61.1330%" y="373" width="10.6673%" height="15" fill="rgb(212,111,17)" fg:x="23892" fg:w="4169"/><text x="61.3830%" y="383.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,429 samples, 8.77%)</title><rect x="63.0265%" y="357" width="8.7739%" height="15" fill="rgb(221,157,24)" fg:x="24632" fg:w="3429"/><text x="63.2765%" y="367.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,280 samples, 8.39%)</title><rect x="63.4077%" y="341" width="8.3926%" height="15" fill="rgb(252,16,13)" fg:x="24781" fg:w="3280"/><text x="63.6577%" y="351.50">[libcrypto.s..</text></g><g><title>asm_sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="71.7747%" y="325" width="0.0256%" height="15" fill="rgb(221,62,2)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="71.7747%" y="309" width="0.0256%" height="15" fill="rgb(247,87,22)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="319.50"></text></g><g><title>irqentry_exit (10 samples, 0.03%)</title><rect x="71.7747%" y="293" width="0.0256%" height="15" fill="rgb(215,73,9)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (10 samples, 0.03%)</title><rect x="71.7747%" y="277" width="0.0256%" height="15" fill="rgb(207,175,33)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (10 samples, 0.03%)</title><rect x="71.7747%" y="261" width="0.0256%" height="15" fill="rgb(243,129,54)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (10 samples, 0.03%)</title><rect x="71.7747%" y="245" width="0.0256%" height="15" fill="rgb(227,119,45)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="255.50"></text></g><g><title>schedule (10 samples, 0.03%)</title><rect x="71.7747%" y="229" width="0.0256%" height="15" fill="rgb(205,109,36)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="239.50"></text></g><g><title>__schedule (10 samples, 0.03%)</title><rect x="71.7747%" y="213" width="0.0256%" height="15" fill="rgb(205,6,39)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="71.7747%" y="197" width="0.0256%" height="15" fill="rgb(221,32,16)" fg:x="28051" fg:w="10"/><text x="72.0247%" y="207.50"></text></g><g><title>CRYPTO_clear_free (106 samples, 0.27%)</title><rect x="71.8336%" y="357" width="0.2712%" height="15" fill="rgb(228,144,50)" fg:x="28074" fg:w="106"/><text x="72.0836%" y="367.50"></text></g><g><title>OPENSSL_cleanse (103 samples, 0.26%)</title><rect x="71.8413%" y="341" width="0.2635%" height="15" fill="rgb(229,201,53)" fg:x="28077" fg:w="103"/><text x="72.0913%" y="351.50"></text></g><g><title>EVP_CIPHER_free (44 samples, 0.11%)</title><rect x="72.1099%" y="357" width="0.1126%" height="15" fill="rgb(249,153,27)" fg:x="28182" fg:w="44"/><text x="72.3599%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_free (199 samples, 0.51%)</title><rect x="71.8080%" y="389" width="0.5092%" height="15" fill="rgb(227,106,25)" fg:x="28064" fg:w="199"/><text x="72.0580%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_reset (198 samples, 0.51%)</title><rect x="71.8106%" y="373" width="0.5066%" height="15" fill="rgb(230,65,29)" fg:x="28065" fg:w="198"/><text x="72.0606%" y="383.50"></text></g><g><title>cfree (37 samples, 0.09%)</title><rect x="72.2225%" y="357" width="0.0947%" height="15" fill="rgb(221,57,46)" fg:x="28226" fg:w="37"/><text x="72.4725%" y="367.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="72.3044%" y="341" width="0.0128%" height="15" fill="rgb(229,161,17)" fg:x="28258" fg:w="5"/><text x="72.5544%" y="351.50"></text></g><g><title>cfree (9 samples, 0.02%)</title><rect x="72.3172%" y="389" width="0.0230%" height="15" fill="rgb(222,213,11)" fg:x="28263" fg:w="9"/><text x="72.5672%" y="399.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="72.3300%" y="373" width="0.0102%" height="15" fill="rgb(235,35,13)" fg:x="28268" fg:w="4"/><text x="72.5800%" y="383.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec&gt; (212 samples, 0.54%)</title><rect x="71.8003%" y="437" width="0.5424%" height="15" fill="rgb(233,158,34)" fg:x="28061" fg:w="212"/><text x="72.0503%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::CipherCtx&gt; (212 samples, 0.54%)</title><rect x="71.8003%" y="421" width="0.5424%" height="15" fill="rgb(215,151,48)" fg:x="28061" fg:w="212"/><text x="72.0503%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::CipherCtx as core::ops::drop::Drop&gt;::drop (212 samples, 0.54%)</title><rect x="71.8003%" y="405" width="0.5424%" height="15" fill="rgb(229,84,14)" fg:x="28061" fg:w="212"/><text x="72.0503%" y="415.50"></text></g><g><title>[libcrypto.so.3] (26 samples, 0.07%)</title><rect x="72.3556%" y="405" width="0.0665%" height="15" fill="rgb(229,68,14)" fg:x="28278" fg:w="26"/><text x="72.6056%" y="415.50"></text></g><g><title>[libcrypto.so.3] (26 samples, 0.07%)</title><rect x="72.3556%" y="389" width="0.0665%" height="15" fill="rgb(243,106,26)" fg:x="28278" fg:w="26"/><text x="72.6056%" y="399.50"></text></g><g><title>[libcrypto.so.3] (26 samples, 0.07%)</title><rect x="72.3556%" y="373" width="0.0665%" height="15" fill="rgb(206,45,38)" fg:x="28278" fg:w="26"/><text x="72.6056%" y="383.50"></text></g><g><title>CRYPTO_gcm128_finish (24 samples, 0.06%)</title><rect x="72.3607%" y="357" width="0.0614%" height="15" fill="rgb(226,6,15)" fg:x="28280" fg:w="24"/><text x="72.6107%" y="367.50"></text></g><g><title>[libcrypto.so.3] (18 samples, 0.05%)</title><rect x="72.3760%" y="341" width="0.0461%" height="15" fill="rgb(232,22,54)" fg:x="28286" fg:w="18"/><text x="72.6260%" y="351.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (36 samples, 0.09%)</title><rect x="72.3428%" y="437" width="0.0921%" height="15" fill="rgb(229,222,32)" fg:x="28273" fg:w="36"/><text x="72.5928%" y="447.50"></text></g><g><title>EVP_DecryptFinal_ex (36 samples, 0.09%)</title><rect x="72.3428%" y="421" width="0.0921%" height="15" fill="rgb(228,62,29)" fg:x="28273" fg:w="36"/><text x="72.5928%" y="431.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="72.4221%" y="405" width="0.0128%" height="15" fill="rgb(251,103,34)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="415.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="72.4221%" y="389" width="0.0128%" height="15" fill="rgb(233,12,30)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="399.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="72.4221%" y="373" width="0.0128%" height="15" fill="rgb(238,52,0)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="383.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="72.4221%" y="357" width="0.0128%" height="15" fill="rgb(223,98,5)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="367.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="72.4221%" y="341" width="0.0128%" height="15" fill="rgb(228,75,37)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="351.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="72.4221%" y="325" width="0.0128%" height="15" fill="rgb(205,115,49)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="335.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="72.4221%" y="309" width="0.0128%" height="15" fill="rgb(250,154,43)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="319.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="72.4221%" y="293" width="0.0128%" height="15" fill="rgb(226,43,29)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="303.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="72.4221%" y="277" width="0.0128%" height="15" fill="rgb(249,228,39)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="287.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="72.4221%" y="261" width="0.0128%" height="15" fill="rgb(216,79,43)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="271.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="72.4221%" y="245" width="0.0128%" height="15" fill="rgb(228,95,12)" fg:x="28304" fg:w="5"/><text x="72.6721%" y="255.50"></text></g><g><title>OSSL_PARAM_get_octet_string (7 samples, 0.02%)</title><rect x="72.5577%" y="389" width="0.0179%" height="15" fill="rgb(249,221,15)" fg:x="28357" fg:w="7"/><text x="72.8077%" y="399.50"></text></g><g><title>[libcrypto.so.3] (5 samples, 0.01%)</title><rect x="72.5628%" y="373" width="0.0128%" height="15" fill="rgb(233,34,13)" fg:x="28359" fg:w="5"/><text x="72.8128%" y="383.50"></text></g><g><title>[libc.so.6] (12 samples, 0.03%)</title><rect x="72.6191%" y="373" width="0.0307%" height="15" fill="rgb(214,103,39)" fg:x="28381" fg:w="12"/><text x="72.8691%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (30 samples, 0.08%)</title><rect x="72.5756%" y="389" width="0.0768%" height="15" fill="rgb(251,126,39)" fg:x="28364" fg:w="30"/><text x="72.8256%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (336 samples, 0.86%)</title><rect x="71.8003%" y="453" width="0.8597%" height="15" fill="rgb(214,216,36)" fg:x="28061" fg:w="336"/><text x="72.0503%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::set_tag (88 samples, 0.23%)</title><rect x="72.4349%" y="437" width="0.2252%" height="15" fill="rgb(220,221,8)" fg:x="28309" fg:w="88"/><text x="72.6849%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (88 samples, 0.23%)</title><rect x="72.4349%" y="421" width="0.2252%" height="15" fill="rgb(240,216,3)" fg:x="28309" fg:w="88"/><text x="72.6849%" y="431.50"></text></g><g><title>[libcrypto.so.3] (49 samples, 0.13%)</title><rect x="72.5347%" y="405" width="0.1254%" height="15" fill="rgb(232,218,17)" fg:x="28348" fg:w="49"/><text x="72.7847%" y="415.50"></text></g><g><title>[libc.so.6] (27 samples, 0.07%)</title><rect x="72.8110%" y="389" width="0.0691%" height="15" fill="rgb(229,163,45)" fg:x="28456" fg:w="27"/><text x="73.0610%" y="399.50"></text></g><g><title>OSSL_PARAM_locate (38 samples, 0.10%)</title><rect x="72.7905%" y="405" width="0.0972%" height="15" fill="rgb(231,110,42)" fg:x="28448" fg:w="38"/><text x="73.0405%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (90 samples, 0.23%)</title><rect x="72.6652%" y="437" width="0.2303%" height="15" fill="rgb(208,170,48)" fg:x="28399" fg:w="90"/><text x="72.9152%" y="447.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="72.7598%" y="421" width="0.1356%" height="15" fill="rgb(239,116,25)" fg:x="28436" fg:w="53"/><text x="73.0098%" y="431.50"></text></g><g><title>[libc.so.6] (24 samples, 0.06%)</title><rect x="73.1078%" y="341" width="0.0614%" height="15" fill="rgb(219,200,50)" fg:x="28572" fg:w="24"/><text x="73.3578%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (48 samples, 0.12%)</title><rect x="73.0515%" y="357" width="0.1228%" height="15" fill="rgb(245,200,0)" fg:x="28550" fg:w="48"/><text x="73.3015%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (82 samples, 0.21%)</title><rect x="72.9671%" y="389" width="0.2098%" height="15" fill="rgb(245,119,33)" fg:x="28517" fg:w="82"/><text x="73.2171%" y="399.50"></text></g><g><title>[libcrypto.so.3] (60 samples, 0.15%)</title><rect x="73.0234%" y="373" width="0.1535%" height="15" fill="rgb(231,125,12)" fg:x="28539" fg:w="60"/><text x="73.2734%" y="383.50"></text></g><g><title>[libc.so.6] (18 samples, 0.05%)</title><rect x="73.2537%" y="341" width="0.0461%" height="15" fill="rgb(216,96,41)" fg:x="28629" fg:w="18"/><text x="73.5037%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (34 samples, 0.09%)</title><rect x="73.2178%" y="357" width="0.0870%" height="15" fill="rgb(248,43,45)" fg:x="28615" fg:w="34"/><text x="73.4678%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_key_length (51 samples, 0.13%)</title><rect x="73.1769%" y="389" width="0.1305%" height="15" fill="rgb(217,222,7)" fg:x="28599" fg:w="51"/><text x="73.4269%" y="399.50"></text></g><g><title>[libcrypto.so.3] (42 samples, 0.11%)</title><rect x="73.1999%" y="373" width="0.1075%" height="15" fill="rgb(233,28,6)" fg:x="28608" fg:w="42"/><text x="73.4499%" y="383.50"></text></g><g><title>CRYPTO_THREAD_read_lock (155 samples, 0.40%)</title><rect x="73.3560%" y="341" width="0.3966%" height="15" fill="rgb(231,218,15)" fg:x="28669" fg:w="155"/><text x="73.6060%" y="351.50"></text></g><g><title>pthread_rwlock_rdlock (151 samples, 0.39%)</title><rect x="73.3663%" y="325" width="0.3864%" height="15" fill="rgb(226,171,48)" fg:x="28673" fg:w="151"/><text x="73.6163%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (88 samples, 0.23%)</title><rect x="73.7629%" y="325" width="0.2252%" height="15" fill="rgb(235,201,9)" fg:x="28828" fg:w="88"/><text x="74.0129%" y="335.50"></text></g><g><title>CRYPTO_THREAD_unlock (91 samples, 0.23%)</title><rect x="73.7577%" y="341" width="0.2328%" height="15" fill="rgb(217,80,15)" fg:x="28826" fg:w="91"/><text x="74.0077%" y="351.50"></text></g><g><title>EVP_CIPHER_up_ref (29 samples, 0.07%)</title><rect x="73.9957%" y="341" width="0.0742%" height="15" fill="rgb(219,152,8)" fg:x="28919" fg:w="29"/><text x="74.2457%" y="351.50"></text></g><g><title>OPENSSL_LH_retrieve (59 samples, 0.15%)</title><rect x="74.0699%" y="341" width="0.1510%" height="15" fill="rgb(243,107,38)" fg:x="28948" fg:w="59"/><text x="74.3199%" y="351.50"></text></g><g><title>[libcrypto.so.3] (51 samples, 0.13%)</title><rect x="74.0904%" y="325" width="0.1305%" height="15" fill="rgb(231,17,5)" fg:x="28956" fg:w="51"/><text x="74.3404%" y="335.50"></text></g><g><title>pthread_rwlock_rdlock (40 samples, 0.10%)</title><rect x="74.2465%" y="309" width="0.1023%" height="15" fill="rgb(209,25,54)" fg:x="29017" fg:w="40"/><text x="74.4965%" y="319.50"></text></g><g><title>CRYPTO_THREAD_read_lock (43 samples, 0.11%)</title><rect x="74.2465%" y="325" width="0.1100%" height="15" fill="rgb(219,0,2)" fg:x="29017" fg:w="43"/><text x="74.4965%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (49 samples, 0.13%)</title><rect x="74.3667%" y="309" width="0.1254%" height="15" fill="rgb(246,9,5)" fg:x="29064" fg:w="49"/><text x="74.6167%" y="319.50"></text></g><g><title>CRYPTO_THREAD_unlock (54 samples, 0.14%)</title><rect x="74.3565%" y="325" width="0.1382%" height="15" fill="rgb(226,159,4)" fg:x="29060" fg:w="54"/><text x="74.6065%" y="335.50"></text></g><g><title>OPENSSL_strnlen (7 samples, 0.02%)</title><rect x="74.5074%" y="309" width="0.0179%" height="15" fill="rgb(219,175,34)" fg:x="29119" fg:w="7"/><text x="74.7574%" y="319.50"></text></g><g><title>CRYPTO_strndup (15 samples, 0.04%)</title><rect x="74.5023%" y="325" width="0.0384%" height="15" fill="rgb(236,10,46)" fg:x="29117" fg:w="15"/><text x="74.7523%" y="335.50"></text></g><g><title>OPENSSL_strcasecmp (25 samples, 0.06%)</title><rect x="74.7531%" y="293" width="0.0640%" height="15" fill="rgb(240,211,16)" fg:x="29215" fg:w="25"/><text x="75.0031%" y="303.50"></text></g><g><title>OPENSSL_LH_retrieve (150 samples, 0.38%)</title><rect x="74.5407%" y="325" width="0.3838%" height="15" fill="rgb(205,3,43)" fg:x="29132" fg:w="150"/><text x="74.7907%" y="335.50"></text></g><g><title>[libcrypto.so.3] (142 samples, 0.36%)</title><rect x="74.5612%" y="309" width="0.3633%" height="15" fill="rgb(245,7,22)" fg:x="29140" fg:w="142"/><text x="74.8112%" y="319.50"></text></g><g><title>[libcrypto.so.3] (42 samples, 0.11%)</title><rect x="74.8171%" y="293" width="0.1075%" height="15" fill="rgb(239,132,32)" fg:x="29240" fg:w="42"/><text x="75.0671%" y="303.50"></text></g><g><title>[libcrypto.so.3] (298 samples, 0.76%)</title><rect x="74.2234%" y="341" width="0.7625%" height="15" fill="rgb(228,202,34)" fg:x="29008" fg:w="298"/><text x="74.4734%" y="351.50"></text></g><g><title>cfree (23 samples, 0.06%)</title><rect x="74.9271%" y="325" width="0.0589%" height="15" fill="rgb(254,200,22)" fg:x="29283" fg:w="23"/><text x="75.1771%" y="335.50"></text></g><g><title>[libc.so.6] (6 samples, 0.02%)</title><rect x="74.9706%" y="309" width="0.0154%" height="15" fill="rgb(219,10,39)" fg:x="29300" fg:w="6"/><text x="75.2206%" y="319.50"></text></g><g><title>[libcrypto.so.3] (652 samples, 1.67%)</title><rect x="73.3253%" y="357" width="1.6683%" height="15" fill="rgb(226,210,39)" fg:x="28657" fg:w="652"/><text x="73.5753%" y="367.50"></text></g><g><title>EVP_CIPHER_fetch (660 samples, 1.69%)</title><rect x="73.3074%" y="389" width="1.6888%" height="15" fill="rgb(208,219,16)" fg:x="28650" fg:w="660"/><text x="73.5574%" y="399.50"></text></g><g><title>[libcrypto.so.3] (658 samples, 1.68%)</title><rect x="73.3125%" y="373" width="1.6836%" height="15" fill="rgb(216,158,51)" fg:x="28652" fg:w="658"/><text x="73.5625%" y="383.50"></text></g><g><title>EVP_CIPHER_free (15 samples, 0.04%)</title><rect x="74.9962%" y="389" width="0.0384%" height="15" fill="rgb(233,14,44)" fg:x="29310" fg:w="15"/><text x="75.2462%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (14 samples, 0.04%)</title><rect x="75.0345%" y="389" width="0.0358%" height="15" fill="rgb(237,97,39)" fg:x="29325" fg:w="14"/><text x="75.2845%" y="399.50"></text></g><g><title>CRYPTO_malloc (4 samples, 0.01%)</title><rect x="75.1036%" y="357" width="0.0102%" height="15" fill="rgb(218,198,43)" fg:x="29352" fg:w="4"/><text x="75.3536%" y="367.50"></text></g><g><title>[libc.so.6] (8 samples, 0.02%)</title><rect x="75.1139%" y="357" width="0.0205%" height="15" fill="rgb(231,104,20)" fg:x="29356" fg:w="8"/><text x="75.3639%" y="367.50"></text></g><g><title>malloc (7 samples, 0.02%)</title><rect x="75.1343%" y="357" width="0.0179%" height="15" fill="rgb(254,36,13)" fg:x="29364" fg:w="7"/><text x="75.3843%" y="367.50"></text></g><g><title>CRYPTO_zalloc (21 samples, 0.05%)</title><rect x="75.1011%" y="373" width="0.0537%" height="15" fill="rgb(248,14,50)" fg:x="29351" fg:w="21"/><text x="75.3511%" y="383.50"></text></g><g><title>CRYPTO_gcm128_init (149 samples, 0.38%)</title><rect x="75.1702%" y="357" width="0.3812%" height="15" fill="rgb(217,107,29)" fg:x="29378" fg:w="149"/><text x="75.4202%" y="367.50"></text></g><g><title>[libcrypto.so.3] (122 samples, 0.31%)</title><rect x="75.2392%" y="341" width="0.3122%" height="15" fill="rgb(251,169,33)" fg:x="29405" fg:w="122"/><text x="75.4892%" y="351.50"></text></g><g><title>[libcrypto.so.3] (188 samples, 0.48%)</title><rect x="75.1574%" y="373" width="0.4810%" height="15" fill="rgb(217,108,32)" fg:x="29373" fg:w="188"/><text x="75.4074%" y="383.50"></text></g><g><title>[libcrypto.so.3] (34 samples, 0.09%)</title><rect x="75.5514%" y="357" width="0.0870%" height="15" fill="rgb(219,66,42)" fg:x="29527" fg:w="34"/><text x="75.8014%" y="367.50"></text></g><g><title>EVP_CipherInit_ex (1,072 samples, 2.74%)</title><rect x="72.8980%" y="421" width="2.7430%" height="15" fill="rgb(206,180,7)" fg:x="28490" fg:w="1072"/><text x="73.1480%" y="431.50">EV..</text></g><g><title>[libcrypto.so.3] (1,072 samples, 2.74%)</title><rect x="72.8980%" y="405" width="2.7430%" height="15" fill="rgb(208,226,31)" fg:x="28490" fg:w="1072"/><text x="73.1480%" y="415.50">[l..</text></g><g><title>[libcrypto.so.3] (221 samples, 0.57%)</title><rect x="75.0755%" y="389" width="0.5655%" height="15" fill="rgb(218,26,49)" fg:x="29341" fg:w="221"/><text x="75.3255%" y="399.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (1,074 samples, 2.75%)</title><rect x="72.8955%" y="437" width="2.7481%" height="15" fill="rgb(233,197,48)" fg:x="28489" fg:w="1074"/><text x="73.1455%" y="447.50">zs..</text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="75.6486%" y="405" width="0.0102%" height="15" fill="rgb(252,181,51)" fg:x="29565" fg:w="4"/><text x="75.8986%" y="415.50"></text></g><g><title>malloc (15 samples, 0.04%)</title><rect x="75.6589%" y="405" width="0.0384%" height="15" fill="rgb(253,90,19)" fg:x="29569" fg:w="15"/><text x="75.9089%" y="415.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (1,188 samples, 3.04%)</title><rect x="72.6600%" y="453" width="3.0398%" height="15" fill="rgb(215,171,30)" fg:x="28397" fg:w="1188"/><text x="72.9100%" y="463.50">&lt;zs..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::new (22 samples, 0.06%)</title><rect x="75.6435%" y="437" width="0.0563%" height="15" fill="rgb(214,222,9)" fg:x="29563" fg:w="22"/><text x="75.8935%" y="447.50"></text></g><g><title>CRYPTO_zalloc (22 samples, 0.06%)</title><rect x="75.6435%" y="421" width="0.0563%" height="15" fill="rgb(223,3,22)" fg:x="29563" fg:w="22"/><text x="75.8935%" y="431.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::Index&lt;I&gt; for [T]&gt;::index (5 samples, 0.01%)</title><rect x="75.7024%" y="453" width="0.0128%" height="15" fill="rgb(225,196,46)" fg:x="29586" fg:w="5"/><text x="75.9524%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index (5 samples, 0.01%)</title><rect x="75.7024%" y="437" width="0.0128%" height="15" fill="rgb(209,110,37)" fg:x="29586" fg:w="5"/><text x="75.9524%" y="447.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (4 samples, 0.01%)</title><rect x="75.7049%" y="421" width="0.0102%" height="15" fill="rgb(249,89,12)" fg:x="29587" fg:w="4"/><text x="75.9549%" y="431.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (4 samples, 0.01%)</title><rect x="75.7049%" y="405" width="0.0102%" height="15" fill="rgb(226,27,33)" fg:x="29587" fg:w="4"/><text x="75.9549%" y="415.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::add (4 samples, 0.01%)</title><rect x="75.7049%" y="389" width="0.0102%" height="15" fill="rgb(213,82,22)" fg:x="29587" fg:w="4"/><text x="75.9549%" y="399.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::offset (4 samples, 0.01%)</title><rect x="75.7049%" y="373" width="0.0102%" height="15" fill="rgb(248,140,0)" fg:x="29587" fg:w="4"/><text x="75.9549%" y="383.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (6 samples, 0.02%)</title><rect x="75.7152%" y="453" width="0.0154%" height="15" fill="rgb(228,106,3)" fg:x="29591" fg:w="6"/><text x="75.9652%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (6 samples, 0.02%)</title><rect x="75.7152%" y="437" width="0.0154%" height="15" fill="rgb(209,23,37)" fg:x="29591" fg:w="6"/><text x="75.9652%" y="447.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (183 samples, 0.47%)</title><rect x="75.7305%" y="453" width="0.4682%" height="15" fill="rgb(241,93,50)" fg:x="29597" fg:w="183"/><text x="75.9805%" y="463.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (183 samples, 0.47%)</title><rect x="75.7305%" y="437" width="0.4682%" height="15" fill="rgb(253,46,43)" fg:x="29597" fg:w="183"/><text x="75.9805%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (181 samples, 0.46%)</title><rect x="75.7356%" y="421" width="0.4631%" height="15" fill="rgb(226,206,43)" fg:x="29599" fg:w="181"/><text x="75.9856%" y="431.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (181 samples, 0.46%)</title><rect x="75.7356%" y="405" width="0.4631%" height="15" fill="rgb(217,54,7)" fg:x="29599" fg:w="181"/><text x="75.9856%" y="415.50"></text></g><g><title>[libc.so.6] (181 samples, 0.46%)</title><rect x="75.7356%" y="389" width="0.4631%" height="15" fill="rgb(223,5,52)" fg:x="29599" fg:w="181"/><text x="75.9856%" y="399.50"></text></g><g><title>zssp::zeta::receive_payload_in_place (6,109 samples, 15.63%)</title><rect x="60.6008%" y="469" width="15.6312%" height="15" fill="rgb(206,52,46)" fg:x="23684" fg:w="6109"/><text x="60.8508%" y="479.50">zssp::zeta::receive_payl..</text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::update (13 samples, 0.03%)</title><rect x="76.1988%" y="453" width="0.0333%" height="15" fill="rgb(253,136,11)" fg:x="29780" fg:w="13"/><text x="76.4488%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_max (13 samples, 0.03%)</title><rect x="76.1988%" y="437" width="0.0333%" height="15" fill="rgb(208,106,33)" fg:x="29780" fg:w="13"/><text x="76.4488%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_umax (13 samples, 0.03%)</title><rect x="76.1988%" y="421" width="0.0333%" height="15" fill="rgb(206,54,4)" fg:x="29780" fg:w="13"/><text x="76.4488%" y="431.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8,570 samples, 21.93%)</title><rect x="54.5034%" y="485" width="21.9283%" height="15" fill="rgb(213,3,15)" fg:x="21301" fg:w="8570"/><text x="54.7534%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::receive</text></g><g><title>zssp::zssp::parse_fragment_header (78 samples, 0.20%)</title><rect x="76.2320%" y="469" width="0.1996%" height="15" fill="rgb(252,211,39)" fg:x="29793" fg:w="78"/><text x="76.4820%" y="479.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (6 samples, 0.02%)</title><rect x="76.4163%" y="453" width="0.0154%" height="15" fill="rgb(223,6,36)" fg:x="29865" fg:w="6"/><text x="76.6663%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (6 samples, 0.02%)</title><rect x="76.4163%" y="437" width="0.0154%" height="15" fill="rgb(252,169,45)" fg:x="29865" fg:w="6"/><text x="76.6663%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (60 samples, 0.15%)</title><rect x="76.5237%" y="437" width="0.1535%" height="15" fill="rgb(212,48,26)" fg:x="29907" fg:w="60"/><text x="76.7737%" y="447.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (60 samples, 0.15%)</title><rect x="76.5237%" y="421" width="0.1535%" height="15" fill="rgb(251,102,48)" fg:x="29907" fg:w="60"/><text x="76.7737%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (58 samples, 0.15%)</title><rect x="76.5288%" y="405" width="0.1484%" height="15" fill="rgb(243,208,16)" fg:x="29909" fg:w="58"/><text x="76.7788%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (53 samples, 0.14%)</title><rect x="76.5416%" y="389" width="0.1356%" height="15" fill="rgb(219,96,24)" fg:x="29914" fg:w="53"/><text x="76.7916%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_swap (53 samples, 0.14%)</title><rect x="76.5416%" y="373" width="0.1356%" height="15" fill="rgb(219,33,29)" fg:x="29914" fg:w="53"/><text x="76.7916%" y="383.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (4 samples, 0.01%)</title><rect x="76.6772%" y="421" width="0.0102%" height="15" fill="rgb(223,176,5)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="431.50"></text></g><g><title>std::sync::poison::Flag::guard (4 samples, 0.01%)</title><rect x="76.6772%" y="405" width="0.0102%" height="15" fill="rgb(228,140,14)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="415.50"></text></g><g><title>std::thread::panicking (4 samples, 0.01%)</title><rect x="76.6772%" y="389" width="0.0102%" height="15" fill="rgb(217,179,31)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="399.50"></text></g><g><title>std::panicking::panicking (4 samples, 0.01%)</title><rect x="76.6772%" y="373" width="0.0102%" height="15" fill="rgb(230,9,30)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="383.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (4 samples, 0.01%)</title><rect x="76.6772%" y="357" width="0.0102%" height="15" fill="rgb(230,136,20)" fg:x="29967" fg:w="4"/><text x="76.9272%" y="367.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (90 samples, 0.23%)</title><rect x="76.6772%" y="437" width="0.2303%" height="15" fill="rgb(215,210,22)" fg:x="29967" fg:w="90"/><text x="76.9272%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (86 samples, 0.22%)</title><rect x="76.6875%" y="421" width="0.2201%" height="15" fill="rgb(218,43,5)" fg:x="29971" fg:w="86"/><text x="76.9375%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (80 samples, 0.20%)</title><rect x="76.7028%" y="405" width="0.2047%" height="15" fill="rgb(216,11,5)" fg:x="29977" fg:w="80"/><text x="76.9528%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (80 samples, 0.20%)</title><rect x="76.7028%" y="389" width="0.2047%" height="15" fill="rgb(209,82,29)" fg:x="29977" fg:w="80"/><text x="76.9528%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (337 samples, 0.86%)</title><rect x="76.5160%" y="453" width="0.8623%" height="15" fill="rgb(244,115,12)" fg:x="29904" fg:w="337"/><text x="76.7660%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (184 samples, 0.47%)</title><rect x="76.9075%" y="437" width="0.4708%" height="15" fill="rgb(222,82,18)" fg:x="30057" fg:w="184"/><text x="77.1575%" y="447.50"></text></g><g><title>EVP_EncryptUpdate (183 samples, 0.47%)</title><rect x="76.9101%" y="421" width="0.4682%" height="15" fill="rgb(249,227,8)" fg:x="30058" fg:w="183"/><text x="77.1601%" y="431.50"></text></g><g><title>[libcrypto.so.3] (160 samples, 0.41%)</title><rect x="76.9689%" y="405" width="0.4094%" height="15" fill="rgb(253,141,45)" fg:x="30081" fg:w="160"/><text x="77.2189%" y="415.50"></text></g><g><title>[libcrypto.so.3] (121 samples, 0.31%)</title><rect x="77.0687%" y="389" width="0.3096%" height="15" fill="rgb(234,184,4)" fg:x="30120" fg:w="121"/><text x="77.3187%" y="399.50"></text></g><g><title>[libcrypto.so.3] (116 samples, 0.30%)</title><rect x="77.0815%" y="373" width="0.2968%" height="15" fill="rgb(218,194,23)" fg:x="30125" fg:w="116"/><text x="77.3315%" y="383.50"></text></g><g><title>CRYPTO_gcm128_encrypt (243 samples, 0.62%)</title><rect x="77.7340%" y="357" width="0.6218%" height="15" fill="rgb(235,66,41)" fg:x="30380" fg:w="243"/><text x="77.9840%" y="367.50"></text></g><g><title>[libcrypto.so.3] (137 samples, 0.35%)</title><rect x="78.0052%" y="341" width="0.3505%" height="15" fill="rgb(245,217,1)" fg:x="30486" fg:w="137"/><text x="78.2552%" y="351.50"></text></g><g><title>[libcrypto.so.3] (326 samples, 0.83%)</title><rect x="78.6500%" y="341" width="0.8341%" height="15" fill="rgb(229,91,1)" fg:x="30738" fg:w="326"/><text x="78.9000%" y="351.50"></text></g><g><title>[libcrypto.so.3] (21 samples, 0.05%)</title><rect x="79.4304%" y="325" width="0.0537%" height="15" fill="rgb(207,101,30)" fg:x="31043" fg:w="21"/><text x="79.6804%" y="335.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (442 samples, 1.13%)</title><rect x="78.3558%" y="357" width="1.1310%" height="15" fill="rgb(223,82,49)" fg:x="30623" fg:w="442"/><text x="78.6058%" y="367.50"></text></g><g><title>CRYPTO_gcm128_setiv (16 samples, 0.04%)</title><rect x="79.4867%" y="357" width="0.0409%" height="15" fill="rgb(218,167,17)" fg:x="31065" fg:w="16"/><text x="79.7367%" y="367.50"></text></g><g><title>[libcrypto.so.3] (15 samples, 0.04%)</title><rect x="79.4893%" y="341" width="0.0384%" height="15" fill="rgb(208,103,14)" fg:x="31066" fg:w="15"/><text x="79.7393%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (3,402 samples, 8.70%)</title><rect x="77.3783%" y="453" width="8.7048%" height="15" fill="rgb(238,20,8)" fg:x="30241" fg:w="3402"/><text x="77.6283%" y="463.50">&lt;zssp::crypt..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (3,400 samples, 8.70%)</title><rect x="77.3835%" y="437" width="8.6997%" height="15" fill="rgb(218,80,54)" fg:x="30243" fg:w="3400"/><text x="77.6335%" y="447.50">zssp::crypto..</text></g><g><title>EVP_EncryptUpdate (3,399 samples, 8.70%)</title><rect x="77.3860%" y="421" width="8.6971%" height="15" fill="rgb(240,144,17)" fg:x="30244" fg:w="3399"/><text x="77.6360%" y="431.50">EVP_EncryptU..</text></g><g><title>[libcrypto.so.3] (3,327 samples, 8.51%)</title><rect x="77.5702%" y="405" width="8.5129%" height="15" fill="rgb(245,27,50)" fg:x="30316" fg:w="3327"/><text x="77.8202%" y="415.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,322 samples, 8.50%)</title><rect x="77.5830%" y="389" width="8.5001%" height="15" fill="rgb(251,51,7)" fg:x="30321" fg:w="3322"/><text x="77.8330%" y="399.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (3,300 samples, 8.44%)</title><rect x="77.6393%" y="373" width="8.4438%" height="15" fill="rgb(245,217,29)" fg:x="30343" fg:w="3300"/><text x="77.8893%" y="383.50">[libcrypto.s..</text></g><g><title>[libcrypto.so.3] (2,562 samples, 6.56%)</title><rect x="79.5277%" y="357" width="6.5554%" height="15" fill="rgb(221,176,29)" fg:x="31081" fg:w="2562"/><text x="79.7777%" y="367.50">[libcrypt..</text></g><g><title>[libcrypto.so.3] (2,334 samples, 5.97%)</title><rect x="80.1110%" y="341" width="5.9721%" height="15" fill="rgb(212,180,24)" fg:x="31309" fg:w="2334"/><text x="80.3610%" y="351.50">[libcryp..</text></g><g><title>CRYPTO_clear_free (96 samples, 0.25%)</title><rect x="86.1394%" y="357" width="0.2456%" height="15" fill="rgb(254,24,2)" fg:x="33665" fg:w="96"/><text x="86.3894%" y="367.50"></text></g><g><title>OPENSSL_cleanse (96 samples, 0.25%)</title><rect x="86.1394%" y="341" width="0.2456%" height="15" fill="rgb(230,100,2)" fg:x="33665" fg:w="96"/><text x="86.3894%" y="351.50"></text></g><g><title>EVP_CIPHER_free (43 samples, 0.11%)</title><rect x="86.3876%" y="357" width="0.1100%" height="15" fill="rgb(219,142,25)" fg:x="33762" fg:w="43"/><text x="86.6376%" y="367.50"></text></g><g><title>cfree (23 samples, 0.06%)</title><rect x="86.5002%" y="357" width="0.0589%" height="15" fill="rgb(240,73,43)" fg:x="33806" fg:w="23"/><text x="86.7502%" y="367.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="86.5462%" y="341" width="0.0128%" height="15" fill="rgb(214,114,15)" fg:x="33824" fg:w="5"/><text x="86.7962%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_free (185 samples, 0.47%)</title><rect x="86.0882%" y="389" width="0.4734%" height="15" fill="rgb(207,130,4)" fg:x="33645" fg:w="185"/><text x="86.3382%" y="399.50"></text></g><g><title>EVP_CIPHER_CTX_reset (185 samples, 0.47%)</title><rect x="86.0882%" y="373" width="0.4734%" height="15" fill="rgb(221,25,40)" fg:x="33645" fg:w="185"/><text x="86.3382%" y="383.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc&gt; (191 samples, 0.49%)</title><rect x="86.0857%" y="437" width="0.4887%" height="15" fill="rgb(241,184,7)" fg:x="33644" fg:w="191"/><text x="86.3357%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::CipherCtx&gt; (191 samples, 0.49%)</title><rect x="86.0857%" y="421" width="0.4887%" height="15" fill="rgb(235,159,4)" fg:x="33644" fg:w="191"/><text x="86.3357%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::CipherCtx as core::ops::drop::Drop&gt;::drop (191 samples, 0.49%)</title><rect x="86.0857%" y="405" width="0.4887%" height="15" fill="rgb(214,87,48)" fg:x="33644" fg:w="191"/><text x="86.3357%" y="415.50"></text></g><g><title>cfree (5 samples, 0.01%)</title><rect x="86.5616%" y="389" width="0.0128%" height="15" fill="rgb(246,198,24)" fg:x="33830" fg:w="5"/><text x="86.8116%" y="399.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="86.5641%" y="373" width="0.0102%" height="15" fill="rgb(209,66,40)" fg:x="33831" fg:w="4"/><text x="86.8141%" y="383.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (69 samples, 0.18%)</title><rect x="86.5744%" y="437" width="0.1766%" height="15" fill="rgb(233,147,39)" fg:x="33835" fg:w="69"/><text x="86.8244%" y="447.50"></text></g><g><title>EVP_EncryptFinal_ex (67 samples, 0.17%)</title><rect x="86.5795%" y="421" width="0.1714%" height="15" fill="rgb(231,145,52)" fg:x="33837" fg:w="67"/><text x="86.8295%" y="431.50"></text></g><g><title>[libcrypto.so.3] (51 samples, 0.13%)</title><rect x="86.6204%" y="405" width="0.1305%" height="15" fill="rgb(206,20,26)" fg:x="33853" fg:w="51"/><text x="86.8704%" y="415.50"></text></g><g><title>[libcrypto.so.3] (50 samples, 0.13%)</title><rect x="86.6230%" y="389" width="0.1279%" height="15" fill="rgb(238,220,4)" fg:x="33854" fg:w="50"/><text x="86.8730%" y="399.50"></text></g><g><title>[libcrypto.so.3] (45 samples, 0.12%)</title><rect x="86.6358%" y="373" width="0.1151%" height="15" fill="rgb(252,195,42)" fg:x="33859" fg:w="45"/><text x="86.8858%" y="383.50"></text></g><g><title>CRYPTO_gcm128_tag (45 samples, 0.12%)</title><rect x="86.6358%" y="357" width="0.1151%" height="15" fill="rgb(209,10,6)" fg:x="33859" fg:w="45"/><text x="86.8858%" y="367.50"></text></g><g><title>CRYPTO_gcm128_finish (37 samples, 0.09%)</title><rect x="86.6563%" y="341" width="0.0947%" height="15" fill="rgb(229,3,52)" fg:x="33867" fg:w="37"/><text x="86.9063%" y="351.50"></text></g><g><title>[libcrypto.so.3] (22 samples, 0.06%)</title><rect x="86.6946%" y="325" width="0.0563%" height="15" fill="rgb(253,49,37)" fg:x="33882" fg:w="22"/><text x="86.9446%" y="335.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="86.9147%" y="373" width="0.0384%" height="15" fill="rgb(240,103,49)" fg:x="33968" fg:w="15"/><text x="87.1647%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (39 samples, 0.10%)</title><rect x="86.8584%" y="389" width="0.0998%" height="15" fill="rgb(250,182,30)" fg:x="33946" fg:w="39"/><text x="87.1084%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::finish (345 samples, 0.88%)</title><rect x="86.0831%" y="453" width="0.8828%" height="15" fill="rgb(248,8,30)" fg:x="33643" fg:w="345"/><text x="86.3331%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::get_tag (84 samples, 0.21%)</title><rect x="86.7509%" y="437" width="0.2149%" height="15" fill="rgb(237,120,30)" fg:x="33904" fg:w="84"/><text x="87.0009%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (83 samples, 0.21%)</title><rect x="86.7535%" y="421" width="0.2124%" height="15" fill="rgb(221,146,34)" fg:x="33905" fg:w="83"/><text x="87.0035%" y="431.50"></text></g><g><title>[libcrypto.so.3] (51 samples, 0.13%)</title><rect x="86.8354%" y="405" width="0.1305%" height="15" fill="rgb(242,55,13)" fg:x="33937" fg:w="51"/><text x="87.0854%" y="415.50"></text></g><g><title>[libc.so.6] (25 samples, 0.06%)</title><rect x="87.0861%" y="389" width="0.0640%" height="15" fill="rgb(242,112,31)" fg:x="34035" fg:w="25"/><text x="87.3361%" y="399.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.1373%" y="373" width="0.0128%" height="15" fill="rgb(249,192,27)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="383.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.1373%" y="357" width="0.0128%" height="15" fill="rgb(208,204,44)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="367.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="87.1373%" y="341" width="0.0128%" height="15" fill="rgb(208,93,54)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="351.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="87.1373%" y="325" width="0.0128%" height="15" fill="rgb(242,1,31)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="335.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="87.1373%" y="309" width="0.0128%" height="15" fill="rgb(241,83,25)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="319.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="87.1373%" y="293" width="0.0128%" height="15" fill="rgb(205,169,50)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="303.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="87.1373%" y="277" width="0.0128%" height="15" fill="rgb(239,186,37)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="287.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="87.1373%" y="261" width="0.0128%" height="15" fill="rgb(205,221,10)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="271.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="87.1373%" y="245" width="0.0128%" height="15" fill="rgb(218,196,15)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="255.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="87.1373%" y="229" width="0.0128%" height="15" fill="rgb(218,196,35)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="239.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="87.1373%" y="213" width="0.0128%" height="15" fill="rgb(233,63,24)" fg:x="34055" fg:w="5"/><text x="87.3873%" y="223.50"></text></g><g><title>OSSL_PARAM_locate (41 samples, 0.10%)</title><rect x="87.0554%" y="405" width="0.1049%" height="15" fill="rgb(225,8,4)" fg:x="34023" fg:w="41"/><text x="87.3054%" y="415.50"></text></g><g><title>strcmp@plt (4 samples, 0.01%)</title><rect x="87.1501%" y="389" width="0.0102%" height="15" fill="rgb(234,105,35)" fg:x="34060" fg:w="4"/><text x="87.4001%" y="399.50"></text></g><g><title>[libcrypto.so.3] (49 samples, 0.13%)</title><rect x="87.0401%" y="421" width="0.1254%" height="15" fill="rgb(236,21,32)" fg:x="34017" fg:w="49"/><text x="87.2901%" y="431.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="87.1654%" y="277" width="0.0128%" height="15" fill="rgb(228,109,6)" fg:x="34066" fg:w="5"/><text x="87.4154%" y="287.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="87.1654%" y="261" width="0.0128%" height="15" fill="rgb(229,215,31)" fg:x="34066" fg:w="5"/><text x="87.4154%" y="271.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (83 samples, 0.21%)</title><rect x="86.9684%" y="437" width="0.2124%" height="15" fill="rgb(221,52,54)" fg:x="33989" fg:w="83"/><text x="87.2184%" y="447.50"></text></g><g><title>asm_sysvec_reschedule_ipi (6 samples, 0.02%)</title><rect x="87.1654%" y="421" width="0.0154%" height="15" fill="rgb(252,129,43)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="431.50"></text></g><g><title>sysvec_reschedule_ipi (6 samples, 0.02%)</title><rect x="87.1654%" y="405" width="0.0154%" height="15" fill="rgb(248,183,27)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="415.50"></text></g><g><title>irqentry_exit (6 samples, 0.02%)</title><rect x="87.1654%" y="389" width="0.0154%" height="15" fill="rgb(250,0,22)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="399.50"></text></g><g><title>irqentry_exit_to_user_mode (6 samples, 0.02%)</title><rect x="87.1654%" y="373" width="0.0154%" height="15" fill="rgb(213,166,10)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="383.50"></text></g><g><title>exit_to_user_mode_prepare (6 samples, 0.02%)</title><rect x="87.1654%" y="357" width="0.0154%" height="15" fill="rgb(207,163,36)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="367.50"></text></g><g><title>exit_to_user_mode_loop (6 samples, 0.02%)</title><rect x="87.1654%" y="341" width="0.0154%" height="15" fill="rgb(208,122,22)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="351.50"></text></g><g><title>schedule (6 samples, 0.02%)</title><rect x="87.1654%" y="325" width="0.0154%" height="15" fill="rgb(207,104,49)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="335.50"></text></g><g><title>__schedule (6 samples, 0.02%)</title><rect x="87.1654%" y="309" width="0.0154%" height="15" fill="rgb(248,211,50)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="319.50"></text></g><g><title>finish_task_switch.isra.0 (6 samples, 0.02%)</title><rect x="87.1654%" y="293" width="0.0154%" height="15" fill="rgb(217,13,45)" fg:x="34066" fg:w="6"/><text x="87.4154%" y="303.50"></text></g><g><title>[libc.so.6] (21 samples, 0.05%)</title><rect x="87.4136%" y="341" width="0.0537%" height="15" fill="rgb(211,216,49)" fg:x="34163" fg:w="21"/><text x="87.6636%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (41 samples, 0.10%)</title><rect x="87.3676%" y="357" width="0.1049%" height="15" fill="rgb(221,58,53)" fg:x="34145" fg:w="41"/><text x="87.6176%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (82 samples, 0.21%)</title><rect x="87.2652%" y="389" width="0.2098%" height="15" fill="rgb(220,112,41)" fg:x="34105" fg:w="82"/><text x="87.5152%" y="399.50"></text></g><g><title>[libcrypto.so.3] (54 samples, 0.14%)</title><rect x="87.3369%" y="373" width="0.1382%" height="15" fill="rgb(236,38,28)" fg:x="34133" fg:w="54"/><text x="87.5869%" y="383.50"></text></g><g><title>[libc.so.6] (9 samples, 0.02%)</title><rect x="87.5646%" y="341" width="0.0230%" height="15" fill="rgb(227,195,22)" fg:x="34222" fg:w="9"/><text x="87.8146%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (26 samples, 0.07%)</title><rect x="87.5288%" y="357" width="0.0665%" height="15" fill="rgb(214,55,33)" fg:x="34208" fg:w="26"/><text x="87.7788%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_key_length (48 samples, 0.12%)</title><rect x="87.4751%" y="389" width="0.1228%" height="15" fill="rgb(248,80,13)" fg:x="34187" fg:w="48"/><text x="87.7251%" y="399.50"></text></g><g><title>[libcrypto.so.3] (40 samples, 0.10%)</title><rect x="87.4955%" y="373" width="0.1023%" height="15" fill="rgb(238,52,6)" fg:x="34195" fg:w="40"/><text x="87.7455%" y="383.50"></text></g><g><title>CRYPTO_THREAD_read_lock (116 samples, 0.30%)</title><rect x="87.6414%" y="341" width="0.2968%" height="15" fill="rgb(224,198,47)" fg:x="34252" fg:w="116"/><text x="87.8914%" y="351.50"></text></g><g><title>pthread_rwlock_rdlock (112 samples, 0.29%)</title><rect x="87.6516%" y="325" width="0.2866%" height="15" fill="rgb(233,171,20)" fg:x="34256" fg:w="112"/><text x="87.9016%" y="335.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.9254%" y="309" width="0.0128%" height="15" fill="rgb(241,30,25)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="319.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.9254%" y="293" width="0.0128%" height="15" fill="rgb(207,171,38)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="303.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="87.9254%" y="277" width="0.0128%" height="15" fill="rgb(234,70,1)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="287.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="87.9254%" y="261" width="0.0128%" height="15" fill="rgb(232,178,18)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="271.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="87.9254%" y="245" width="0.0128%" height="15" fill="rgb(241,78,40)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="255.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="87.9254%" y="229" width="0.0128%" height="15" fill="rgb(222,35,25)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="239.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="87.9254%" y="213" width="0.0128%" height="15" fill="rgb(207,92,16)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="223.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="87.9254%" y="197" width="0.0128%" height="15" fill="rgb(216,59,51)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="207.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="87.9254%" y="181" width="0.0128%" height="15" fill="rgb(213,80,28)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="191.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="87.9254%" y="165" width="0.0128%" height="15" fill="rgb(220,93,7)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="175.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="87.9254%" y="149" width="0.0128%" height="15" fill="rgb(225,24,44)" fg:x="34363" fg:w="5"/><text x="88.1754%" y="159.50"></text></g><g><title>pthread_rwlock_unlock (95 samples, 0.24%)</title><rect x="87.9535%" y="325" width="0.2431%" height="15" fill="rgb(243,74,40)" fg:x="34374" fg:w="95"/><text x="88.2035%" y="335.50"></text></g><g><title>asm_sysvec_reschedule_ipi (4 samples, 0.01%)</title><rect x="88.1864%" y="309" width="0.0102%" height="15" fill="rgb(228,39,7)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="319.50"></text></g><g><title>sysvec_reschedule_ipi (4 samples, 0.01%)</title><rect x="88.1864%" y="293" width="0.0102%" height="15" fill="rgb(227,79,8)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="303.50"></text></g><g><title>irqentry_exit (4 samples, 0.01%)</title><rect x="88.1864%" y="277" width="0.0102%" height="15" fill="rgb(236,58,11)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="287.50"></text></g><g><title>irqentry_exit_to_user_mode (4 samples, 0.01%)</title><rect x="88.1864%" y="261" width="0.0102%" height="15" fill="rgb(249,63,35)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="271.50"></text></g><g><title>exit_to_user_mode_prepare (4 samples, 0.01%)</title><rect x="88.1864%" y="245" width="0.0102%" height="15" fill="rgb(252,114,16)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="255.50"></text></g><g><title>exit_to_user_mode_loop (4 samples, 0.01%)</title><rect x="88.1864%" y="229" width="0.0102%" height="15" fill="rgb(254,151,24)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="239.50"></text></g><g><title>schedule (4 samples, 0.01%)</title><rect x="88.1864%" y="213" width="0.0102%" height="15" fill="rgb(253,54,39)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="223.50"></text></g><g><title>__schedule (4 samples, 0.01%)</title><rect x="88.1864%" y="197" width="0.0102%" height="15" fill="rgb(243,25,45)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="207.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="88.1864%" y="181" width="0.0102%" height="15" fill="rgb(234,134,9)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="191.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="88.1864%" y="165" width="0.0102%" height="15" fill="rgb(227,166,31)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="175.50"></text></g><g><title>perf_pmu_nop_void (4 samples, 0.01%)</title><rect x="88.1864%" y="149" width="0.0102%" height="15" fill="rgb(245,143,41)" fg:x="34465" fg:w="4"/><text x="88.4364%" y="159.50"></text></g><g><title>CRYPTO_THREAD_unlock (101 samples, 0.26%)</title><rect x="87.9433%" y="341" width="0.2584%" height="15" fill="rgb(238,181,32)" fg:x="34370" fg:w="101"/><text x="88.1933%" y="351.50"></text></g><g><title>EVP_CIPHER_up_ref (39 samples, 0.10%)</title><rect x="88.2017%" y="341" width="0.0998%" height="15" fill="rgb(224,113,18)" fg:x="34471" fg:w="39"/><text x="88.4517%" y="351.50"></text></g><g><title>OPENSSL_LH_retrieve (56 samples, 0.14%)</title><rect x="88.3015%" y="341" width="0.1433%" height="15" fill="rgb(240,229,28)" fg:x="34510" fg:w="56"/><text x="88.5515%" y="351.50"></text></g><g><title>[libcrypto.so.3] (48 samples, 0.12%)</title><rect x="88.3220%" y="325" width="0.1228%" height="15" fill="rgb(250,185,3)" fg:x="34518" fg:w="48"/><text x="88.5720%" y="335.50"></text></g><g><title>[libcrypto.so.3] (6 samples, 0.02%)</title><rect x="88.4295%" y="309" width="0.0154%" height="15" fill="rgb(212,59,25)" fg:x="34560" fg:w="6"/><text x="88.6795%" y="319.50"></text></g><g><title>pthread_rwlock_rdlock (20 samples, 0.05%)</title><rect x="88.4602%" y="309" width="0.0512%" height="15" fill="rgb(221,87,20)" fg:x="34572" fg:w="20"/><text x="88.7102%" y="319.50"></text></g><g><title>CRYPTO_THREAD_read_lock (24 samples, 0.06%)</title><rect x="88.4576%" y="325" width="0.0614%" height="15" fill="rgb(213,74,28)" fg:x="34571" fg:w="24"/><text x="88.7076%" y="335.50"></text></g><g><title>pthread_rwlock_unlock (51 samples, 0.13%)</title><rect x="88.5267%" y="309" width="0.1305%" height="15" fill="rgb(224,132,34)" fg:x="34598" fg:w="51"/><text x="88.7767%" y="319.50"></text></g><g><title>CRYPTO_THREAD_unlock (54 samples, 0.14%)</title><rect x="88.5241%" y="325" width="0.1382%" height="15" fill="rgb(222,101,24)" fg:x="34597" fg:w="54"/><text x="88.7741%" y="335.50"></text></g><g><title>CRYPTO_strndup (10 samples, 0.03%)</title><rect x="88.6725%" y="325" width="0.0256%" height="15" fill="rgb(254,142,4)" fg:x="34655" fg:w="10"/><text x="88.9225%" y="335.50"></text></g><g><title>malloc (6 samples, 0.02%)</title><rect x="88.6828%" y="309" width="0.0154%" height="15" fill="rgb(230,229,49)" fg:x="34659" fg:w="6"/><text x="88.9328%" y="319.50"></text></g><g><title>OPENSSL_strcasecmp (44 samples, 0.11%)</title><rect x="88.8926%" y="293" width="0.1126%" height="15" fill="rgb(238,70,47)" fg:x="34741" fg:w="44"/><text x="89.1426%" y="303.50"></text></g><g><title>OPENSSL_LH_retrieve (173 samples, 0.44%)</title><rect x="88.6981%" y="325" width="0.4427%" height="15" fill="rgb(231,160,17)" fg:x="34665" fg:w="173"/><text x="88.9481%" y="335.50"></text></g><g><title>[libcrypto.so.3] (157 samples, 0.40%)</title><rect x="88.7391%" y="309" width="0.4017%" height="15" fill="rgb(218,68,53)" fg:x="34681" fg:w="157"/><text x="88.9891%" y="319.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="89.0052%" y="293" width="0.1356%" height="15" fill="rgb(236,111,10)" fg:x="34785" fg:w="53"/><text x="89.2552%" y="303.50"></text></g><g><title>cfree (17 samples, 0.04%)</title><rect x="89.1408%" y="325" width="0.0435%" height="15" fill="rgb(224,34,41)" fg:x="34838" fg:w="17"/><text x="89.3908%" y="335.50"></text></g><g><title>[libc.so.6] (6 samples, 0.02%)</title><rect x="89.1689%" y="309" width="0.0154%" height="15" fill="rgb(241,118,19)" fg:x="34849" fg:w="6"/><text x="89.4189%" y="319.50"></text></g><g><title>[libcrypto.so.3] (290 samples, 0.74%)</title><rect x="88.4448%" y="341" width="0.7420%" height="15" fill="rgb(238,129,25)" fg:x="34566" fg:w="290"/><text x="88.6948%" y="351.50"></text></g><g><title>EVP_CIPHER_fetch (622 samples, 1.59%)</title><rect x="87.5979%" y="389" width="1.5915%" height="15" fill="rgb(238,22,31)" fg:x="34235" fg:w="622"/><text x="87.8479%" y="399.50"></text></g><g><title>[libcrypto.so.3] (620 samples, 1.59%)</title><rect x="87.6030%" y="373" width="1.5864%" height="15" fill="rgb(222,174,48)" fg:x="34237" fg:w="620"/><text x="87.8530%" y="383.50"></text></g><g><title>[libcrypto.so.3] (612 samples, 1.57%)</title><rect x="87.6235%" y="357" width="1.5659%" height="15" fill="rgb(206,152,40)" fg:x="34245" fg:w="612"/><text x="87.8735%" y="367.50"></text></g><g><title>EVP_CIPHER_free (14 samples, 0.04%)</title><rect x="89.1894%" y="389" width="0.0358%" height="15" fill="rgb(218,99,54)" fg:x="34857" fg:w="14"/><text x="89.4394%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (18 samples, 0.05%)</title><rect x="89.2252%" y="389" width="0.0461%" height="15" fill="rgb(220,174,26)" fg:x="34871" fg:w="18"/><text x="89.4752%" y="399.50"></text></g><g><title>CRYPTO_malloc (4 samples, 0.01%)</title><rect x="89.2943%" y="357" width="0.0102%" height="15" fill="rgb(245,116,9)" fg:x="34898" fg:w="4"/><text x="89.5443%" y="367.50"></text></g><g><title>[libc.so.6] (9 samples, 0.02%)</title><rect x="89.3045%" y="357" width="0.0230%" height="15" fill="rgb(209,72,35)" fg:x="34902" fg:w="9"/><text x="89.5545%" y="367.50"></text></g><g><title>malloc (8 samples, 0.02%)</title><rect x="89.3276%" y="357" width="0.0205%" height="15" fill="rgb(226,126,21)" fg:x="34911" fg:w="8"/><text x="89.5776%" y="367.50"></text></g><g><title>CRYPTO_zalloc (24 samples, 0.06%)</title><rect x="89.2917%" y="373" width="0.0614%" height="15" fill="rgb(227,192,1)" fg:x="34897" fg:w="24"/><text x="89.5417%" y="383.50"></text></g><g><title>OPENSSL_init_crypto (4 samples, 0.01%)</title><rect x="89.3532%" y="373" width="0.0102%" height="15" fill="rgb(237,180,29)" fg:x="34921" fg:w="4"/><text x="89.6032%" y="383.50"></text></g><g><title>CRYPTO_gcm128_init (157 samples, 0.40%)</title><rect x="89.3685%" y="357" width="0.4017%" height="15" fill="rgb(230,197,35)" fg:x="34927" fg:w="157"/><text x="89.6185%" y="367.50"></text></g><g><title>[libcrypto.so.3] (141 samples, 0.36%)</title><rect x="89.4094%" y="341" width="0.3608%" height="15" fill="rgb(246,193,31)" fg:x="34943" fg:w="141"/><text x="89.6594%" y="351.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="89.8675%" y="213" width="0.0102%" height="15" fill="rgb(241,36,4)" fg:x="35122" fg:w="4"/><text x="90.1175%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="89.8675%" y="197" width="0.0102%" height="15" fill="rgb(241,130,17)" fg:x="35122" fg:w="4"/><text x="90.1175%" y="207.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="89.8675%" y="181" width="0.0102%" height="15" fill="rgb(206,137,32)" fg:x="35122" fg:w="4"/><text x="90.1175%" y="191.50"></text></g><g><title>EVP_CipherInit_ex (1,051 samples, 2.69%)</title><rect x="87.1910%" y="421" width="2.6892%" height="15" fill="rgb(237,228,51)" fg:x="34076" fg:w="1051"/><text x="87.4410%" y="431.50">EV..</text></g><g><title>[libcrypto.so.3] (1,051 samples, 2.69%)</title><rect x="87.1910%" y="405" width="2.6892%" height="15" fill="rgb(243,6,42)" fg:x="34076" fg:w="1051"/><text x="87.4410%" y="415.50">[l..</text></g><g><title>[libcrypto.so.3] (235 samples, 0.60%)</title><rect x="89.2790%" y="389" width="0.6013%" height="15" fill="rgb(251,74,28)" fg:x="34892" fg:w="235"/><text x="89.5290%" y="399.50"></text></g><g><title>[libcrypto.so.3] (202 samples, 0.52%)</title><rect x="89.3634%" y="373" width="0.5169%" height="15" fill="rgb(218,20,49)" fg:x="34925" fg:w="202"/><text x="89.6134%" y="383.50"></text></g><g><title>[libcrypto.so.3] (43 samples, 0.11%)</title><rect x="89.7702%" y="357" width="0.1100%" height="15" fill="rgb(238,28,14)" fg:x="35084" fg:w="43"/><text x="90.0202%" y="367.50"></text></g><g><title>asm_sysvec_reschedule_ipi (6 samples, 0.02%)</title><rect x="89.8649%" y="341" width="0.0154%" height="15" fill="rgb(229,40,46)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (6 samples, 0.02%)</title><rect x="89.8649%" y="325" width="0.0154%" height="15" fill="rgb(244,195,20)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="335.50"></text></g><g><title>irqentry_exit (6 samples, 0.02%)</title><rect x="89.8649%" y="309" width="0.0154%" height="15" fill="rgb(253,56,35)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (6 samples, 0.02%)</title><rect x="89.8649%" y="293" width="0.0154%" height="15" fill="rgb(210,149,44)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (6 samples, 0.02%)</title><rect x="89.8649%" y="277" width="0.0154%" height="15" fill="rgb(240,135,12)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (6 samples, 0.02%)</title><rect x="89.8649%" y="261" width="0.0154%" height="15" fill="rgb(251,24,50)" fg:x="35121" fg:w="6"/><text x="90.1149%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="89.8675%" y="245" width="0.0128%" height="15" fill="rgb(243,200,47)" fg:x="35122" fg:w="5"/><text x="90.1175%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="89.8675%" y="229" width="0.0128%" height="15" fill="rgb(224,166,26)" fg:x="35122" fg:w="5"/><text x="90.1175%" y="239.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (1,054 samples, 2.70%)</title><rect x="87.1859%" y="437" width="2.6969%" height="15" fill="rgb(233,0,47)" fg:x="34074" fg:w="1054"/><text x="87.4359%" y="447.50">zs..</text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="89.8854%" y="405" width="0.0102%" height="15" fill="rgb(253,80,5)" fg:x="35129" fg:w="4"/><text x="90.1354%" y="415.50"></text></g><g><title>malloc (7 samples, 0.02%)</title><rect x="89.8956%" y="405" width="0.0179%" height="15" fill="rgb(214,133,25)" fg:x="35133" fg:w="7"/><text x="90.1456%" y="415.50"></text></g><g><title>CRYPTO_zalloc (13 samples, 0.03%)</title><rect x="89.8828%" y="421" width="0.0333%" height="15" fill="rgb(209,27,14)" fg:x="35128" fg:w="13"/><text x="90.1328%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (1,154 samples, 2.95%)</title><rect x="86.9659%" y="453" width="2.9528%" height="15" fill="rgb(219,102,51)" fg:x="33988" fg:w="1154"/><text x="87.2159%" y="463.50">&lt;zs..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::new (14 samples, 0.04%)</title><rect x="89.8828%" y="437" width="0.0358%" height="15" fill="rgb(237,18,16)" fg:x="35128" fg:w="14"/><text x="90.1328%" y="447.50"></text></g><g><title>__rdl_alloc (6 samples, 0.02%)</title><rect x="89.9238%" y="277" width="0.0154%" height="15" fill="rgb(241,85,17)" fg:x="35144" fg:w="6"/><text x="90.1738%" y="287.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::alloc (6 samples, 0.02%)</title><rect x="89.9238%" y="261" width="0.0154%" height="15" fill="rgb(236,90,42)" fg:x="35144" fg:w="6"/><text x="90.1738%" y="271.50"></text></g><g><title>[libc.so.6] (49 samples, 0.13%)</title><rect x="93.4804%" y="245" width="0.1254%" height="15" fill="rgb(249,57,21)" fg:x="36534" fg:w="49"/><text x="93.7304%" y="255.50"></text></g><g><title>[libc.so.6] (850 samples, 2.17%)</title><rect x="91.4436%" y="261" width="2.1749%" height="15" fill="rgb(243,12,36)" fg:x="35738" fg:w="850"/><text x="91.6936%" y="271.50">[..</text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="93.6058%" y="245" width="0.0128%" height="15" fill="rgb(253,128,47)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="255.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="93.6058%" y="229" width="0.0128%" height="15" fill="rgb(207,33,20)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="239.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="93.6058%" y="213" width="0.0128%" height="15" fill="rgb(233,215,35)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="223.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="93.6058%" y="197" width="0.0128%" height="15" fill="rgb(249,188,52)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="93.6058%" y="181" width="0.0128%" height="15" fill="rgb(225,12,32)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="191.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="93.6058%" y="165" width="0.0128%" height="15" fill="rgb(247,98,14)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="175.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="93.6058%" y="149" width="0.0128%" height="15" fill="rgb(247,219,48)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="159.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="93.6058%" y="133" width="0.0128%" height="15" fill="rgb(253,60,48)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="93.6058%" y="117" width="0.0128%" height="15" fill="rgb(245,15,52)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="93.6058%" y="101" width="0.0128%" height="15" fill="rgb(220,133,28)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="111.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="93.6058%" y="85" width="0.0128%" height="15" fill="rgb(217,180,4)" fg:x="36583" fg:w="5"/><text x="93.8558%" y="95.50"></text></g><g><title>__get_user_nocheck_4 (8 samples, 0.02%)</title><rect x="93.6800%" y="149" width="0.0205%" height="15" fill="rgb(251,24,1)" fg:x="36612" fg:w="8"/><text x="93.9300%" y="159.50"></text></g><g><title>futex_q_lock (13 samples, 0.03%)</title><rect x="93.7004%" y="149" width="0.0333%" height="15" fill="rgb(212,185,49)" fg:x="36620" fg:w="13"/><text x="93.9504%" y="159.50"></text></g><g><title>futex_q_unlock (5 samples, 0.01%)</title><rect x="93.7337%" y="149" width="0.0128%" height="15" fill="rgb(215,175,22)" fg:x="36633" fg:w="5"/><text x="93.9837%" y="159.50"></text></g><g><title>__x64_sys_futex (35 samples, 0.09%)</title><rect x="93.6620%" y="213" width="0.0896%" height="15" fill="rgb(250,205,14)" fg:x="36605" fg:w="35"/><text x="93.9120%" y="223.50"></text></g><g><title>do_futex (33 samples, 0.08%)</title><rect x="93.6672%" y="197" width="0.0844%" height="15" fill="rgb(225,211,22)" fg:x="36607" fg:w="33"/><text x="93.9172%" y="207.50"></text></g><g><title>futex_wait (32 samples, 0.08%)</title><rect x="93.6697%" y="181" width="0.0819%" height="15" fill="rgb(251,179,42)" fg:x="36608" fg:w="32"/><text x="93.9197%" y="191.50"></text></g><g><title>futex_wait_setup (28 samples, 0.07%)</title><rect x="93.6800%" y="165" width="0.0716%" height="15" fill="rgb(208,216,51)" fg:x="36612" fg:w="28"/><text x="93.9300%" y="175.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (37 samples, 0.09%)</title><rect x="93.6620%" y="245" width="0.0947%" height="15" fill="rgb(235,36,11)" fg:x="36605" fg:w="37"/><text x="93.9120%" y="255.50"></text></g><g><title>do_syscall_64 (37 samples, 0.09%)</title><rect x="93.6620%" y="229" width="0.0947%" height="15" fill="rgb(213,189,28)" fg:x="36605" fg:w="37"/><text x="93.9120%" y="239.50"></text></g><g><title>__lll_lock_wait_private (55 samples, 0.14%)</title><rect x="93.6185%" y="261" width="0.1407%" height="15" fill="rgb(227,203,42)" fg:x="36588" fg:w="55"/><text x="93.8685%" y="271.50"></text></g><g><title>futex_wake_mark (11 samples, 0.03%)</title><rect x="93.9179%" y="165" width="0.0281%" height="15" fill="rgb(244,72,36)" fg:x="36705" fg:w="11"/><text x="94.1679%" y="175.50"></text></g><g><title>wake_q_add_safe (4 samples, 0.01%)</title><rect x="93.9461%" y="165" width="0.0102%" height="15" fill="rgb(213,53,17)" fg:x="36716" fg:w="4"/><text x="94.1961%" y="175.50"></text></g><g><title>call_function_single_prep_ipi (4 samples, 0.01%)</title><rect x="94.0459%" y="101" width="0.0102%" height="15" fill="rgb(207,167,3)" fg:x="36755" fg:w="4"/><text x="94.2959%" y="111.50"></text></g><g><title>__smp_call_single_queue (17 samples, 0.04%)</title><rect x="94.0459%" y="117" width="0.0435%" height="15" fill="rgb(216,98,30)" fg:x="36755" fg:w="17"/><text x="94.2959%" y="127.50"></text></g><g><title>native_send_call_func_single_ipi (13 samples, 0.03%)</title><rect x="94.0561%" y="101" width="0.0333%" height="15" fill="rgb(236,123,15)" fg:x="36759" fg:w="13"/><text x="94.3061%" y="111.50"></text></g><g><title>x2apic_send_IPI (12 samples, 0.03%)</title><rect x="94.0586%" y="85" width="0.0307%" height="15" fill="rgb(248,81,50)" fg:x="36760" fg:w="12"/><text x="94.3086%" y="95.50"></text></g><g><title>native_write_msr (10 samples, 0.03%)</title><rect x="94.0638%" y="69" width="0.0256%" height="15" fill="rgb(214,120,4)" fg:x="36762" fg:w="10"/><text x="94.3138%" y="79.50"></text></g><g><title>llist_add_batch (10 samples, 0.03%)</title><rect x="94.0894%" y="117" width="0.0256%" height="15" fill="rgb(208,179,34)" fg:x="36772" fg:w="10"/><text x="94.3394%" y="127.50"></text></g><g><title>futex_wake (123 samples, 0.31%)</title><rect x="93.8028%" y="181" width="0.3147%" height="15" fill="rgb(227,140,7)" fg:x="36660" fg:w="123"/><text x="94.0528%" y="191.50"></text></g><g><title>wake_up_q (63 samples, 0.16%)</title><rect x="93.9563%" y="165" width="0.1612%" height="15" fill="rgb(214,22,6)" fg:x="36720" fg:w="63"/><text x="94.2063%" y="175.50"></text></g><g><title>try_to_wake_up (58 samples, 0.15%)</title><rect x="93.9691%" y="149" width="0.1484%" height="15" fill="rgb(207,137,27)" fg:x="36725" fg:w="58"/><text x="94.2191%" y="159.50"></text></g><g><title>ttwu_queue_wakelist (38 samples, 0.10%)</title><rect x="94.0203%" y="133" width="0.0972%" height="15" fill="rgb(210,8,46)" fg:x="36745" fg:w="38"/><text x="94.2703%" y="143.50"></text></g><g><title>__x64_sys_futex (133 samples, 0.34%)</title><rect x="93.7797%" y="213" width="0.3403%" height="15" fill="rgb(240,16,54)" fg:x="36651" fg:w="133"/><text x="94.0297%" y="223.50"></text></g><g><title>do_futex (132 samples, 0.34%)</title><rect x="93.7823%" y="197" width="0.3378%" height="15" fill="rgb(211,209,29)" fg:x="36652" fg:w="132"/><text x="94.0323%" y="207.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (145 samples, 0.37%)</title><rect x="93.7746%" y="245" width="0.3710%" height="15" fill="rgb(226,228,24)" fg:x="36649" fg:w="145"/><text x="94.0246%" y="255.50"></text></g><g><title>do_syscall_64 (144 samples, 0.37%)</title><rect x="93.7772%" y="229" width="0.3685%" height="15" fill="rgb(222,84,9)" fg:x="36650" fg:w="144"/><text x="94.0272%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (7 samples, 0.02%)</title><rect x="94.1277%" y="213" width="0.0179%" height="15" fill="rgb(234,203,30)" fg:x="36787" fg:w="7"/><text x="94.3777%" y="223.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="94.1328%" y="197" width="0.0128%" height="15" fill="rgb(238,109,14)" fg:x="36789" fg:w="5"/><text x="94.3828%" y="207.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (1,653 samples, 4.23%)</title><rect x="89.9186%" y="373" width="4.2296%" height="15" fill="rgb(233,206,34)" fg:x="35142" fg:w="1653"/><text x="90.1686%" y="383.50">alloc..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (1,653 samples, 4.23%)</title><rect x="89.9186%" y="357" width="4.2296%" height="15" fill="rgb(220,167,47)" fg:x="35142" fg:w="1653"/><text x="90.1686%" y="367.50">alloc..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (1,653 samples, 4.23%)</title><rect x="89.9186%" y="341" width="4.2296%" height="15" fill="rgb(238,105,10)" fg:x="35142" fg:w="1653"/><text x="90.1686%" y="351.50">alloc..</text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (1,651 samples, 4.22%)</title><rect x="89.9238%" y="325" width="4.2245%" height="15" fill="rgb(213,227,17)" fg:x="35144" fg:w="1651"/><text x="90.1738%" y="335.50">&lt;allo..</text></g><g><title>alloc::alloc::Global::alloc_impl (1,651 samples, 4.22%)</title><rect x="89.9238%" y="309" width="4.2245%" height="15" fill="rgb(217,132,38)" fg:x="35144" fg:w="1651"/><text x="90.1738%" y="319.50">alloc..</text></g><g><title>alloc::alloc::alloc (1,651 samples, 4.22%)</title><rect x="89.9238%" y="293" width="4.2245%" height="15" fill="rgb(242,146,4)" fg:x="35144" fg:w="1651"/><text x="90.1738%" y="303.50">alloc..</text></g><g><title>malloc (1,644 samples, 4.21%)</title><rect x="89.9417%" y="277" width="4.2065%" height="15" fill="rgb(212,61,9)" fg:x="35151" fg:w="1644"/><text x="90.1917%" y="287.50">malloc</text></g><g><title>__lll_lock_wake_private (152 samples, 0.39%)</title><rect x="93.7593%" y="261" width="0.3889%" height="15" fill="rgb(247,126,22)" fg:x="36643" fg:w="152"/><text x="94.0093%" y="271.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (1,857 samples, 4.75%)</title><rect x="89.9186%" y="437" width="4.7515%" height="15" fill="rgb(220,196,2)" fg:x="35142" fg:w="1857"/><text x="90.1686%" y="447.50">alloc:..</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (1,857 samples, 4.75%)</title><rect x="89.9186%" y="421" width="4.7515%" height="15" fill="rgb(208,46,4)" fg:x="35142" fg:w="1857"/><text x="90.1686%" y="431.50">alloc:..</text></g><g><title>alloc::slice::hack::to_vec (1,857 samples, 4.75%)</title><rect x="89.9186%" y="405" width="4.7515%" height="15" fill="rgb(252,104,46)" fg:x="35142" fg:w="1857"/><text x="90.1686%" y="415.50">alloc:..</text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (1,857 samples, 4.75%)</title><rect x="89.9186%" y="389" width="4.7515%" height="15" fill="rgb(237,152,48)" fg:x="35142" fg:w="1857"/><text x="90.1686%" y="399.50">&lt;T as ..</text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (204 samples, 0.52%)</title><rect x="94.1482%" y="373" width="0.5220%" height="15" fill="rgb(221,59,37)" fg:x="36795" fg:w="204"/><text x="94.3982%" y="383.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (204 samples, 0.52%)</title><rect x="94.1482%" y="357" width="0.5220%" height="15" fill="rgb(209,202,51)" fg:x="36795" fg:w="204"/><text x="94.3982%" y="367.50"></text></g><g><title>[libc.so.6] (203 samples, 0.52%)</title><rect x="94.1508%" y="341" width="0.5194%" height="15" fill="rgb(228,81,30)" fg:x="36796" fg:w="203"/><text x="94.4008%" y="351.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="97.9556%" y="405" width="0.0128%" height="15" fill="rgb(227,42,39)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="415.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="97.9556%" y="389" width="0.0128%" height="15" fill="rgb(221,26,2)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="399.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="97.9556%" y="373" width="0.0128%" height="15" fill="rgb(254,61,31)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="383.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="97.9556%" y="357" width="0.0128%" height="15" fill="rgb(222,173,38)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="367.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="97.9556%" y="341" width="0.0128%" height="15" fill="rgb(218,50,12)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="351.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="97.9556%" y="325" width="0.0128%" height="15" fill="rgb(223,88,40)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="335.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="97.9556%" y="309" width="0.0128%" height="15" fill="rgb(237,54,19)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="319.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="97.9556%" y="293" width="0.0128%" height="15" fill="rgb(251,129,25)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="303.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="97.9556%" y="277" width="0.0128%" height="15" fill="rgb(238,97,19)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="287.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="97.9556%" y="261" width="0.0128%" height="15" fill="rgb(240,169,18)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="271.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="97.9556%" y="245" width="0.0128%" height="15" fill="rgb(230,187,49)" fg:x="38283" fg:w="5"/><text x="98.2056%" y="255.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (100 samples, 0.26%)</title><rect x="98.0707%" y="373" width="0.2559%" height="15" fill="rgb(209,44,26)" fg:x="38328" fg:w="100"/><text x="98.3207%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (100 samples, 0.26%)</title><rect x="98.0707%" y="357" width="0.2559%" height="15" fill="rgb(244,0,6)" fg:x="38328" fg:w="100"/><text x="98.3207%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (155 samples, 0.40%)</title><rect x="98.0119%" y="389" width="0.3966%" height="15" fill="rgb(248,18,21)" fg:x="38305" fg:w="155"/><text x="98.2619%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (32 samples, 0.08%)</title><rect x="98.3266%" y="373" width="0.0819%" height="15" fill="rgb(245,180,19)" fg:x="38428" fg:w="32"/><text x="98.5766%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (32 samples, 0.08%)</title><rect x="98.3266%" y="357" width="0.0819%" height="15" fill="rgb(252,118,36)" fg:x="38428" fg:w="32"/><text x="98.5766%" y="367.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::write (4 samples, 0.01%)</title><rect x="98.4136%" y="373" width="0.0102%" height="15" fill="rgb(210,224,19)" fg:x="38462" fg:w="4"/><text x="98.6636%" y="383.50"></text></g><g><title>core::ptr::write (4 samples, 0.01%)</title><rect x="98.4136%" y="357" width="0.0102%" height="15" fill="rgb(218,30,24)" fg:x="38462" fg:w="4"/><text x="98.6636%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (185 samples, 0.47%)</title><rect x="97.9684%" y="405" width="0.4734%" height="15" fill="rgb(219,75,50)" fg:x="38288" fg:w="185"/><text x="98.2184%" y="415.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (13 samples, 0.03%)</title><rect x="98.4085%" y="389" width="0.0333%" height="15" fill="rgb(234,72,50)" fg:x="38460" fg:w="13"/><text x="98.6585%" y="399.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (7 samples, 0.02%)</title><rect x="98.4238%" y="373" width="0.0179%" height="15" fill="rgb(219,100,48)" fg:x="38466" fg:w="7"/><text x="98.6738%" y="383.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (5 samples, 0.01%)</title><rect x="98.4289%" y="357" width="0.0128%" height="15" fill="rgb(253,5,41)" fg:x="38468" fg:w="5"/><text x="98.6789%" y="367.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="98.4289%" y="341" width="0.0128%" height="15" fill="rgb(247,181,11)" fg:x="38468" fg:w="5"/><text x="98.6789%" y="351.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (3,332 samples, 8.53%)</title><rect x="89.9186%" y="453" width="8.5257%" height="15" fill="rgb(222,223,25)" fg:x="35142" fg:w="3332"/><text x="90.1686%" y="463.50">benchmark::b..</text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (1,474 samples, 3.77%)</title><rect x="94.6727%" y="437" width="3.7716%" height="15" fill="rgb(214,198,28)" fg:x="37000" fg:w="1474"/><text x="94.9227%" y="447.50">std:..</text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (1,473 samples, 3.77%)</title><rect x="94.6753%" y="421" width="3.7690%" height="15" fill="rgb(230,46,43)" fg:x="37001" fg:w="1473"/><text x="94.9253%" y="431.50">std:..</text></g><g><title>core::mem::drop (27 samples, 0.07%)</title><rect x="98.4520%" y="453" width="0.0691%" height="15" fill="rgb(233,65,53)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (27 samples, 0.07%)</title><rect x="98.4520%" y="437" width="0.0691%" height="15" fill="rgb(221,121,27)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="447.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (27 samples, 0.07%)</title><rect x="98.4520%" y="421" width="0.0691%" height="15" fill="rgb(247,70,47)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (27 samples, 0.07%)</title><rect x="98.4520%" y="405" width="0.0691%" height="15" fill="rgb(228,85,35)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (27 samples, 0.07%)</title><rect x="98.4520%" y="389" width="0.0691%" height="15" fill="rgb(209,50,18)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_sub (27 samples, 0.07%)</title><rect x="98.4520%" y="373" width="0.0691%" height="15" fill="rgb(250,19,35)" fg:x="38477" fg:w="27"/><text x="98.7020%" y="383.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (7 samples, 0.02%)</title><rect x="98.5211%" y="453" width="0.0179%" height="15" fill="rgb(253,107,29)" fg:x="38504" fg:w="7"/><text x="98.7711%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (7 samples, 0.02%)</title><rect x="98.5211%" y="437" width="0.0179%" height="15" fill="rgb(252,179,29)" fg:x="38504" fg:w="7"/><text x="98.7711%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (35 samples, 0.09%)</title><rect x="98.5492%" y="421" width="0.0896%" height="15" fill="rgb(238,194,6)" fg:x="38515" fg:w="35"/><text x="98.7992%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (35 samples, 0.09%)</title><rect x="98.5492%" y="405" width="0.0896%" height="15" fill="rgb(238,164,29)" fg:x="38515" fg:w="35"/><text x="98.7992%" y="415.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (36 samples, 0.09%)</title><rect x="98.5492%" y="453" width="0.0921%" height="15" fill="rgb(224,25,9)" fg:x="38515" fg:w="36"/><text x="98.7992%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (36 samples, 0.09%)</title><rect x="98.5492%" y="437" width="0.0921%" height="15" fill="rgb(244,153,23)" fg:x="38515" fg:w="36"/><text x="98.7992%" y="447.50"></text></g><g><title>benchmark::bob_main (18,132 samples, 46.39%)</title><rect x="52.2773%" y="501" width="46.3948%" height="15" fill="rgb(212,203,14)" fg:x="20431" fg:w="18132"/><text x="52.5273%" y="511.50">benchmark::bob_main</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::send (8,692 samples, 22.24%)</title><rect x="76.4316%" y="485" width="22.2404%" height="15" fill="rgb(220,164,20)" fg:x="29871" fg:w="8692"/><text x="76.6816%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::send</text></g><g><title>zssp::zeta::send_payload (8,691 samples, 22.24%)</title><rect x="76.4342%" y="469" width="22.2379%" height="15" fill="rgb(222,203,48)" fg:x="29872" fg:w="8691"/><text x="76.6842%" y="479.50">zssp::zeta::send_payload</text></g><g><title>zssp::zeta::get_counter (12 samples, 0.03%)</title><rect x="98.6413%" y="453" width="0.0307%" height="15" fill="rgb(215,159,22)" fg:x="38551" fg:w="12"/><text x="98.8913%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_add (11 samples, 0.03%)</title><rect x="98.6439%" y="437" width="0.0281%" height="15" fill="rgb(216,183,47)" fg:x="38552" fg:w="11"/><text x="98.8939%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_add (11 samples, 0.03%)</title><rect x="98.6439%" y="421" width="0.0281%" height="15" fill="rgb(229,195,25)" fg:x="38552" fg:w="11"/><text x="98.8939%" y="431.50"></text></g><g><title>cfree (19 samples, 0.05%)</title><rect x="98.6720%" y="501" width="0.0486%" height="15" fill="rgb(224,132,51)" fg:x="38563" fg:w="19"/><text x="98.9220%" y="511.50"></text></g><g><title>clock_gettime (12 samples, 0.03%)</title><rect x="98.7206%" y="501" width="0.0307%" height="15" fill="rgb(240,63,7)" fg:x="38582" fg:w="12"/><text x="98.9706%" y="511.50"></text></g><g><title>core::hash::BuildHasher::hash_one (20 samples, 0.05%)</title><rect x="98.7513%" y="501" width="0.0512%" height="15" fill="rgb(249,182,41)" fg:x="38594" fg:w="20"/><text x="99.0013%" y="511.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (12 samples, 0.03%)</title><rect x="98.7718%" y="485" width="0.0307%" height="15" fill="rgb(243,47,26)" fg:x="38602" fg:w="12"/><text x="99.0218%" y="495.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (4 samples, 0.01%)</title><rect x="98.8025%" y="501" width="0.0102%" height="15" fill="rgb(233,48,2)" fg:x="38614" fg:w="4"/><text x="99.0525%" y="511.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::unwrap (7 samples, 0.02%)</title><rect x="98.8128%" y="501" width="0.0179%" height="15" fill="rgb(244,165,34)" fg:x="38618" fg:w="7"/><text x="99.0628%" y="511.50"></text></g><g><title>pthread_rwlock_rdlock (21 samples, 0.05%)</title><rect x="98.8383%" y="501" width="0.0537%" height="15" fill="rgb(207,89,7)" fg:x="38628" fg:w="21"/><text x="99.0883%" y="511.50"></text></g><g><title>pthread_rwlock_unlock (15 samples, 0.04%)</title><rect x="98.8921%" y="501" width="0.0384%" height="15" fill="rgb(244,117,36)" fg:x="38649" fg:w="15"/><text x="99.1421%" y="511.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (12 samples, 0.03%)</title><rect x="98.9305%" y="501" width="0.0307%" height="15" fill="rgb(226,144,34)" fg:x="38664" fg:w="12"/><text x="99.1805%" y="511.50"></text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (15 samples, 0.04%)</title><rect x="98.9612%" y="501" width="0.0384%" height="15" fill="rgb(213,23,19)" fg:x="38676" fg:w="15"/><text x="99.2112%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (7 samples, 0.02%)</title><rect x="99.0354%" y="485" width="0.0179%" height="15" fill="rgb(217,75,12)" fg:x="38705" fg:w="7"/><text x="99.2854%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv (24 samples, 0.06%)</title><rect x="98.9995%" y="501" width="0.0614%" height="15" fill="rgb(224,159,17)" fg:x="38691" fg:w="24"/><text x="99.2495%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (11 samples, 0.03%)</title><rect x="99.0609%" y="501" width="0.0281%" height="15" fill="rgb(217,118,1)" fg:x="38715" fg:w="11"/><text x="99.3109%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (12 samples, 0.03%)</title><rect x="99.0891%" y="501" width="0.0307%" height="15" fill="rgb(232,180,48)" fg:x="38726" fg:w="12"/><text x="99.3391%" y="511.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (9 samples, 0.02%)</title><rect x="99.1198%" y="501" width="0.0230%" height="15" fill="rgb(230,27,33)" fg:x="38738" fg:w="9"/><text x="99.3698%" y="511.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (19 samples, 0.05%)</title><rect x="99.1428%" y="501" width="0.0486%" height="15" fill="rgb(205,31,21)" fg:x="38747" fg:w="19"/><text x="99.3928%" y="511.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (4 samples, 0.01%)</title><rect x="99.1812%" y="485" width="0.0102%" height="15" fill="rgb(253,59,4)" fg:x="38762" fg:w="4"/><text x="99.4312%" y="495.50"></text></g><g><title>core::sync::atomic::atomic_load (4 samples, 0.01%)</title><rect x="99.1812%" y="469" width="0.0102%" height="15" fill="rgb(224,201,9)" fg:x="38762" fg:w="4"/><text x="99.4312%" y="479.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (6 samples, 0.02%)</title><rect x="99.1914%" y="501" width="0.0154%" height="15" fill="rgb(229,206,30)" fg:x="38766" fg:w="6"/><text x="99.4414%" y="511.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (6 samples, 0.02%)</title><rect x="99.2094%" y="501" width="0.0154%" height="15" fill="rgb(212,67,47)" fg:x="38773" fg:w="6"/><text x="99.4594%" y="511.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (15 samples, 0.04%)</title><rect x="99.2247%" y="501" width="0.0384%" height="15" fill="rgb(211,96,50)" fg:x="38779" fg:w="15"/><text x="99.4747%" y="511.50"></text></g><g><title>std::time::SystemTime::checked_add (5 samples, 0.01%)</title><rect x="99.2631%" y="501" width="0.0128%" height="15" fill="rgb(252,114,18)" fg:x="38794" fg:w="5"/><text x="99.5131%" y="511.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (21 samples, 0.05%)</title><rect x="99.2810%" y="501" width="0.0537%" height="15" fill="rgb(223,58,37)" fg:x="38801" fg:w="21"/><text x="99.5310%" y="511.50"></text></g><g><title>zssp::zeta::from_nonce (5 samples, 0.01%)</title><rect x="99.3347%" y="501" width="0.0128%" height="15" fill="rgb(237,70,4)" fg:x="38822" fg:w="5"/><text x="99.5847%" y="511.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (14 samples, 0.04%)</title><rect x="99.4038%" y="405" width="0.0358%" height="15" fill="rgb(244,85,46)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="415.50"></text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (14 samples, 0.04%)</title><rect x="99.4038%" y="389" width="0.0358%" height="15" fill="rgb(223,39,52)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="399.50"></text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (14 samples, 0.04%)</title><rect x="99.4038%" y="373" width="0.0358%" height="15" fill="rgb(218,200,14)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="383.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (14 samples, 0.04%)</title><rect x="99.4038%" y="357" width="0.0358%" height="15" fill="rgb(208,171,16)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="367.50"></text></g><g><title>alloc::alloc::Global::alloc_impl (14 samples, 0.04%)</title><rect x="99.4038%" y="341" width="0.0358%" height="15" fill="rgb(234,200,18)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="351.50"></text></g><g><title>alloc::alloc::alloc (14 samples, 0.04%)</title><rect x="99.4038%" y="325" width="0.0358%" height="15" fill="rgb(228,45,11)" fg:x="38849" fg:w="14"/><text x="99.6538%" y="335.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (20 samples, 0.05%)</title><rect x="99.4038%" y="469" width="0.0512%" height="15" fill="rgb(237,182,11)" fg:x="38849" fg:w="20"/><text x="99.6538%" y="479.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (20 samples, 0.05%)</title><rect x="99.4038%" y="453" width="0.0512%" height="15" fill="rgb(241,175,49)" fg:x="38849" fg:w="20"/><text x="99.6538%" y="463.50"></text></g><g><title>alloc::slice::hack::to_vec (20 samples, 0.05%)</title><rect x="99.4038%" y="437" width="0.0512%" height="15" fill="rgb(247,38,35)" fg:x="38849" fg:w="20"/><text x="99.6538%" y="447.50"></text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (20 samples, 0.05%)</title><rect x="99.4038%" y="421" width="0.0512%" height="15" fill="rgb(228,39,49)" fg:x="38849" fg:w="20"/><text x="99.6538%" y="431.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (6 samples, 0.02%)</title><rect x="99.4396%" y="405" width="0.0154%" height="15" fill="rgb(226,101,26)" fg:x="38863" fg:w="6"/><text x="99.6896%" y="415.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (6 samples, 0.02%)</title><rect x="99.4396%" y="389" width="0.0154%" height="15" fill="rgb(206,141,19)" fg:x="38863" fg:w="6"/><text x="99.6896%" y="399.50"></text></g><g><title>zssp::zeta::send_payload (50 samples, 0.13%)</title><rect x="99.3501%" y="501" width="0.1279%" height="15" fill="rgb(211,200,13)" fg:x="38828" fg:w="50"/><text x="99.6001%" y="511.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (29 samples, 0.07%)</title><rect x="99.4038%" y="485" width="0.0742%" height="15" fill="rgb(241,121,6)" fg:x="38849" fg:w="29"/><text x="99.6538%" y="495.50"></text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (9 samples, 0.02%)</title><rect x="99.4550%" y="469" width="0.0230%" height="15" fill="rgb(234,221,29)" fg:x="38869" fg:w="9"/><text x="99.7050%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (7 samples, 0.02%)</title><rect x="99.5906%" y="485" width="0.0179%" height="15" fill="rgb(229,136,5)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="495.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="99.5906%" y="469" width="0.0179%" height="15" fill="rgb(238,36,11)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="479.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (7 samples, 0.02%)</title><rect x="99.5906%" y="453" width="0.0179%" height="15" fill="rgb(251,55,41)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (7 samples, 0.02%)</title><rect x="99.5906%" y="437" width="0.0179%" height="15" fill="rgb(242,34,40)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (7 samples, 0.02%)</title><rect x="99.5906%" y="421" width="0.0179%" height="15" fill="rgb(215,42,17)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (7 samples, 0.02%)</title><rect x="99.5906%" y="405" width="0.0179%" height="15" fill="rgb(207,44,46)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (7 samples, 0.02%)</title><rect x="99.5906%" y="389" width="0.0179%" height="15" fill="rgb(211,206,28)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="399.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (7 samples, 0.02%)</title><rect x="99.5906%" y="373" width="0.0179%" height="15" fill="rgb(237,167,16)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="383.50"></text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="99.5906%" y="357" width="0.0179%" height="15" fill="rgb(233,66,6)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="367.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (7 samples, 0.02%)</title><rect x="99.5906%" y="341" width="0.0179%" height="15" fill="rgb(246,123,29)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="351.50"></text></g><g><title>alloc::alloc::dealloc (7 samples, 0.02%)</title><rect x="99.5906%" y="325" width="0.0179%" height="15" fill="rgb(209,62,40)" fg:x="38922" fg:w="7"/><text x="99.8406%" y="335.50"></text></g><g><title>cfree (5 samples, 0.01%)</title><rect x="99.5957%" y="309" width="0.0128%" height="15" fill="rgb(218,4,25)" fg:x="38924" fg:w="5"/><text x="99.8457%" y="319.50"></text></g><g><title>__lll_lock_wake_private (5 samples, 0.01%)</title><rect x="99.5957%" y="293" width="0.0128%" height="15" fill="rgb(253,91,49)" fg:x="38924" fg:w="5"/><text x="99.8457%" y="303.50"></text></g><g><title>__entry_text_start (5 samples, 0.01%)</title><rect x="99.5957%" y="277" width="0.0128%" height="15" fill="rgb(228,155,29)" fg:x="38924" fg:w="5"/><text x="99.8457%" y="287.50"></text></g><g><title>getrandom::imp::getrandom_inner (5 samples, 0.01%)</title><rect x="99.6085%" y="485" width="0.0128%" height="15" fill="rgb(243,57,37)" fg:x="38929" fg:w="5"/><text x="99.8585%" y="495.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (70 samples, 0.18%)</title><rect x="99.4780%" y="501" width="0.1791%" height="15" fill="rgb(244,167,17)" fg:x="38878" fg:w="70"/><text x="99.7280%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (13 samples, 0.03%)</title><rect x="99.6239%" y="485" width="0.0333%" height="15" fill="rgb(207,181,38)" fg:x="38935" fg:w="13"/><text x="99.8739%" y="495.50"></text></g><g><title>[unknown] (37,550 samples, 96.08%)</title><rect x="3.5873%" y="517" width="96.0800%" height="15" fill="rgb(211,8,23)" fg:x="1402" fg:w="37550"/><text x="3.8373%" y="527.50">[unknown]</text></g><g><title>zssp::zssp::parse_fragment_header (4 samples, 0.01%)</title><rect x="99.6571%" y="501" width="0.0102%" height="15" fill="rgb(235,11,44)" fg:x="38948" fg:w="4"/><text x="99.9071%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (31 samples, 0.08%)</title><rect x="99.6674%" y="501" width="0.0793%" height="15" fill="rgb(248,18,52)" fg:x="38952" fg:w="31"/><text x="99.9174%" y="511.50"></text></g><g><title>__bss_start (36 samples, 0.09%)</title><rect x="99.6674%" y="517" width="0.0921%" height="15" fill="rgb(208,4,7)" fg:x="38952" fg:w="36"/><text x="99.9174%" y="527.50"></text></g><g><title>[libcrypto.so.3] (5 samples, 0.01%)</title><rect x="99.7467%" y="501" width="0.0128%" height="15" fill="rgb(240,17,39)" fg:x="38983" fg:w="5"/><text x="99.9967%" y="511.50"></text></g><g><title>_raw_spin_unlock (4 samples, 0.01%)</title><rect x="99.7799%" y="293" width="0.0102%" height="15" fill="rgb(207,170,3)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="303.50"></text></g><g><title>preempt_schedule_thunk (4 samples, 0.01%)</title><rect x="99.7799%" y="277" width="0.0102%" height="15" fill="rgb(236,100,52)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="287.50"></text></g><g><title>preempt_schedule (4 samples, 0.01%)</title><rect x="99.7799%" y="261" width="0.0102%" height="15" fill="rgb(246,78,51)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="271.50"></text></g><g><title>__schedule (4 samples, 0.01%)</title><rect x="99.7799%" y="245" width="0.0102%" height="15" fill="rgb(211,17,15)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="255.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="99.7799%" y="229" width="0.0102%" height="15" fill="rgb(209,59,46)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="239.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="99.7799%" y="213" width="0.0102%" height="15" fill="rgb(210,92,25)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="223.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="99.7799%" y="197" width="0.0102%" height="15" fill="rgb(238,174,52)" fg:x="38996" fg:w="4"/><text x="100.0299%" y="207.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (9 samples, 0.02%)</title><rect x="99.7697%" y="517" width="0.0230%" height="15" fill="rgb(230,73,7)" fg:x="38992" fg:w="9"/><text x="100.0197%" y="527.50"></text></g><g><title>do_syscall_64 (7 samples, 0.02%)</title><rect x="99.7748%" y="501" width="0.0179%" height="15" fill="rgb(243,124,40)" fg:x="38994" fg:w="7"/><text x="100.0248%" y="511.50"></text></g><g><title>__x64_sys_exit_group (6 samples, 0.02%)</title><rect x="99.7774%" y="485" width="0.0154%" height="15" fill="rgb(244,170,11)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="495.50"></text></g><g><title>do_group_exit (6 samples, 0.02%)</title><rect x="99.7774%" y="469" width="0.0154%" height="15" fill="rgb(207,114,54)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="479.50"></text></g><g><title>do_exit (6 samples, 0.02%)</title><rect x="99.7774%" y="453" width="0.0154%" height="15" fill="rgb(205,42,20)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="463.50"></text></g><g><title>exit_mm (6 samples, 0.02%)</title><rect x="99.7774%" y="437" width="0.0154%" height="15" fill="rgb(230,30,28)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="447.50"></text></g><g><title>mmput (6 samples, 0.02%)</title><rect x="99.7774%" y="421" width="0.0154%" height="15" fill="rgb(205,73,54)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="431.50"></text></g><g><title>__mmput (6 samples, 0.02%)</title><rect x="99.7774%" y="405" width="0.0154%" height="15" fill="rgb(254,227,23)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="415.50"></text></g><g><title>exit_mmap (6 samples, 0.02%)</title><rect x="99.7774%" y="389" width="0.0154%" height="15" fill="rgb(228,202,34)" fg:x="38995" fg:w="6"/><text x="100.0274%" y="399.50"></text></g><g><title>unmap_vmas (5 samples, 0.01%)</title><rect x="99.7799%" y="373" width="0.0128%" height="15" fill="rgb(222,225,37)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="383.50"></text></g><g><title>unmap_single_vma (5 samples, 0.01%)</title><rect x="99.7799%" y="357" width="0.0128%" height="15" fill="rgb(221,14,54)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="367.50"></text></g><g><title>unmap_page_range (5 samples, 0.01%)</title><rect x="99.7799%" y="341" width="0.0128%" height="15" fill="rgb(254,102,2)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="351.50"></text></g><g><title>zap_pmd_range.isra.0 (5 samples, 0.01%)</title><rect x="99.7799%" y="325" width="0.0128%" height="15" fill="rgb(232,104,17)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="335.50"></text></g><g><title>zap_pte_range (5 samples, 0.01%)</title><rect x="99.7799%" y="309" width="0.0128%" height="15" fill="rgb(250,220,14)" fg:x="38996" fg:w="5"/><text x="100.0299%" y="319.50"></text></g><g><title>entry_SYSCALL_64_safe_stack (15 samples, 0.04%)</title><rect x="99.7927%" y="517" width="0.0384%" height="15" fill="rgb(241,158,9)" fg:x="39001" fg:w="15"/><text x="100.0427%" y="527.50"></text></g><g><title>ret_from_fork (10 samples, 0.03%)</title><rect x="99.8311%" y="517" width="0.0256%" height="15" fill="rgb(246,9,43)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="527.50"></text></g><g><title>schedule_tail (10 samples, 0.03%)</title><rect x="99.8311%" y="501" width="0.0256%" height="15" fill="rgb(206,73,33)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="511.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="99.8311%" y="485" width="0.0256%" height="15" fill="rgb(222,79,8)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="495.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="99.8311%" y="469" width="0.0256%" height="15" fill="rgb(234,8,54)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="479.50"></text></g><g><title>perf_ctx_enable (10 samples, 0.03%)</title><rect x="99.8311%" y="453" width="0.0256%" height="15" fill="rgb(209,134,38)" fg:x="39016" fg:w="10"/><text x="100.0811%" y="463.50"></text></g><g><title>syscall_return_via_sysret (9 samples, 0.02%)</title><rect x="99.8593%" y="517" width="0.0230%" height="15" fill="rgb(230,127,29)" fg:x="39027" fg:w="9"/><text x="100.1093%" y="527.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9693%" y="501" width="0.0128%" height="15" fill="rgb(242,44,41)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="511.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (5 samples, 0.01%)</title><rect x="99.9693%" y="485" width="0.0128%" height="15" fill="rgb(222,56,43)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="495.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (5 samples, 0.01%)</title><rect x="99.9693%" y="469" width="0.0128%" height="15" fill="rgb(238,39,47)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="479.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (5 samples, 0.01%)</title><rect x="99.9693%" y="453" width="0.0128%" height="15" fill="rgb(226,79,43)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (5 samples, 0.01%)</title><rect x="99.9693%" y="437" width="0.0128%" height="15" fill="rgb(242,105,53)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (5 samples, 0.01%)</title><rect x="99.9693%" y="421" width="0.0128%" height="15" fill="rgb(251,132,46)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9693%" y="405" width="0.0128%" height="15" fill="rgb(231,77,14)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9693%" y="389" width="0.0128%" height="15" fill="rgb(240,135,9)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="399.50"></text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (5 samples, 0.01%)</title><rect x="99.9693%" y="373" width="0.0128%" height="15" fill="rgb(248,109,14)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="383.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (5 samples, 0.01%)</title><rect x="99.9693%" y="357" width="0.0128%" height="15" fill="rgb(227,146,52)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="367.50"></text></g><g><title>alloc::alloc::dealloc (5 samples, 0.01%)</title><rect x="99.9693%" y="341" width="0.0128%" height="15" fill="rgb(232,54,3)" fg:x="39070" fg:w="5"/><text x="100.2193%" y="351.50"></text></g><g><title>benchmark (39,077 samples, 99.99%)</title><rect x="0.0000%" y="533" width="99.9872%" height="15" fill="rgb(229,201,43)" fg:x="0" fg:w="39077"/><text x="0.2500%" y="543.50">benchmark</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (41 samples, 0.10%)</title><rect x="99.8823%" y="517" width="0.1049%" height="15" fill="rgb(252,161,33)" fg:x="39036" fg:w="41"/><text x="100.1323%" y="527.50"></text></g><g><title>perf_event_exec (4 samples, 0.01%)</title><rect x="99.9872%" y="357" width="0.0102%" height="15" fill="rgb(226,146,40)" fg:x="39077" fg:w="4"/><text x="100.2372%" y="367.50"></text></g><g><title>perf_event_enable_on_exec (4 samples, 0.01%)</title><rect x="99.9872%" y="341" width="0.0102%" height="15" fill="rgb(219,47,25)" fg:x="39077" fg:w="4"/><text x="100.2372%" y="351.50"></text></g><g><title>ctx_resched (4 samples, 0.01%)</title><rect x="99.9872%" y="325" width="0.0102%" height="15" fill="rgb(250,135,13)" fg:x="39077" fg:w="4"/><text x="100.2372%" y="335.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="99.9872%" y="309" width="0.0102%" height="15" fill="rgb(219,229,18)" fg:x="39077" fg:w="4"/><text x="100.2372%" y="319.50"></text></g><g><title>all (39,082 samples, 100%)</title><rect x="0.0000%" y="549" width="100.0000%" height="15" fill="rgb(217,152,27)" fg:x="0" fg:w="39082"/><text x="0.2500%" y="559.50"></text></g><g><title>perf-exec (5 samples, 0.01%)</title><rect x="99.9872%" y="533" width="0.0128%" height="15" fill="rgb(225,71,47)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="543.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (5 samples, 0.01%)</title><rect x="99.9872%" y="517" width="0.0128%" height="15" fill="rgb(220,139,14)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="527.50"></text></g><g><title>do_syscall_64 (5 samples, 0.01%)</title><rect x="99.9872%" y="501" width="0.0128%" height="15" fill="rgb(247,54,32)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="511.50"></text></g><g><title>__x64_sys_execve (5 samples, 0.01%)</title><rect x="99.9872%" y="485" width="0.0128%" height="15" fill="rgb(252,131,39)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="495.50"></text></g><g><title>do_execveat_common.isra.0 (5 samples, 0.01%)</title><rect x="99.9872%" y="469" width="0.0128%" height="15" fill="rgb(210,108,39)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="479.50"></text></g><g><title>bprm_execve (5 samples, 0.01%)</title><rect x="99.9872%" y="453" width="0.0128%" height="15" fill="rgb(205,23,29)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="463.50"></text></g><g><title>bprm_execve.part.0 (5 samples, 0.01%)</title><rect x="99.9872%" y="437" width="0.0128%" height="15" fill="rgb(246,139,46)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="447.50"></text></g><g><title>exec_binprm (5 samples, 0.01%)</title><rect x="99.9872%" y="421" width="0.0128%" height="15" fill="rgb(250,81,26)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="431.50"></text></g><g><title>search_binary_handler (5 samples, 0.01%)</title><rect x="99.9872%" y="405" width="0.0128%" height="15" fill="rgb(214,104,7)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="415.50"></text></g><g><title>load_elf_binary (5 samples, 0.01%)</title><rect x="99.9872%" y="389" width="0.0128%" height="15" fill="rgb(233,189,8)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="399.50"></text></g><g><title>begin_new_exec (5 samples, 0.01%)</title><rect x="99.9872%" y="373" width="0.0128%" height="15" fill="rgb(228,141,17)" fg:x="39077" fg:w="5"/><text x="100.2372%" y="383.50"></text></g></svg></svg>
\ No newline at end of file
+]]></script><rect x="0" y="0" width="100%" height="598" fill="url(#background)"/><text id="title" fill="rgb(0,0,0)" x="50.0000%" y="24.00">Flame Graph</text><text id="details" fill="rgb(0,0,0)" x="10" y="581.00"> </text><text id="unzoom" class="hide" fill="rgb(0,0,0)" x="10" y="24.00">Reset Zoom</text><text id="search" fill="rgb(0,0,0)" x="1190" y="24.00">Search</text><text id="matched" fill="rgb(0,0,0)" x="1190" y="581.00"> </text><svg id="frames" x="10" width="1180" total_samples="38833"><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (13 samples, 0.03%)</title><rect x="0.0129%" y="501" width="0.0335%" height="15" fill="rgb(227,0,7)" fg:x="5" fg:w="13"/><text x="0.2629%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (7 samples, 0.02%)</title><rect x="0.0283%" y="485" width="0.0180%" height="15" fill="rgb(217,0,24)" fg:x="11" fg:w="7"/><text x="0.2783%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (28 samples, 0.07%)</title><rect x="0.0464%" y="501" width="0.0721%" height="15" fill="rgb(221,193,54)" fg:x="18" fg:w="28"/><text x="0.2964%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4 samples, 0.01%)</title><rect x="0.1082%" y="485" width="0.0103%" height="15" fill="rgb(248,212,6)" fg:x="42" fg:w="4"/><text x="0.3582%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (68 samples, 0.18%)</title><rect x="0.1185%" y="501" width="0.1751%" height="15" fill="rgb(208,68,35)" fg:x="46" fg:w="68"/><text x="0.3685%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (4 samples, 0.01%)</title><rect x="0.2936%" y="485" width="0.0103%" height="15" fill="rgb(232,128,0)" fg:x="114" fg:w="4"/><text x="0.5436%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (6 samples, 0.02%)</title><rect x="0.2936%" y="501" width="0.0155%" height="15" fill="rgb(207,160,47)" fg:x="114" fg:w="6"/><text x="0.5436%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (102 samples, 0.26%)</title><rect x="0.3090%" y="501" width="0.2627%" height="15" fill="rgb(228,23,34)" fg:x="120" fg:w="102"/><text x="0.5590%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (4 samples, 0.01%)</title><rect x="0.5768%" y="501" width="0.0103%" height="15" fill="rgb(218,30,26)" fg:x="224" fg:w="4"/><text x="0.8268%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (5 samples, 0.01%)</title><rect x="0.5871%" y="501" width="0.0129%" height="15" fill="rgb(220,122,19)" fg:x="228" fg:w="5"/><text x="0.8371%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt (8 samples, 0.02%)</title><rect x="0.6000%" y="501" width="0.0206%" height="15" fill="rgb(250,228,42)" fg:x="233" fg:w="8"/><text x="0.8500%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (22 samples, 0.06%)</title><rect x="0.6206%" y="501" width="0.0567%" height="15" fill="rgb(240,193,28)" fg:x="241" fg:w="22"/><text x="0.8706%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt (17 samples, 0.04%)</title><rect x="0.6773%" y="501" width="0.0438%" height="15" fill="rgb(216,20,37)" fg:x="263" fg:w="17"/><text x="0.9273%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (15 samples, 0.04%)</title><rect x="0.7210%" y="501" width="0.0386%" height="15" fill="rgb(206,188,39)" fg:x="280" fg:w="15"/><text x="0.9710%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (7 samples, 0.02%)</title><rect x="0.7597%" y="501" width="0.0180%" height="15" fill="rgb(217,207,13)" fg:x="295" fg:w="7"/><text x="1.0097%" y="511.50"></text></g><g><title>CRYPTO_gcm128_tag (4 samples, 0.01%)</title><rect x="0.7777%" y="501" width="0.0103%" height="15" fill="rgb(231,73,38)" fg:x="302" fg:w="4"/><text x="1.0277%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (9 samples, 0.02%)</title><rect x="0.7880%" y="501" width="0.0232%" height="15" fill="rgb(225,20,46)" fg:x="306" fg:w="9"/><text x="1.0380%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (14 samples, 0.04%)</title><rect x="0.8163%" y="501" width="0.0361%" height="15" fill="rgb(210,31,41)" fg:x="317" fg:w="14"/><text x="1.0663%" y="511.50"></text></g><g><title>EVP_CIPHER_get_block_size (12 samples, 0.03%)</title><rect x="0.8601%" y="501" width="0.0309%" height="15" fill="rgb(221,200,47)" fg:x="334" fg:w="12"/><text x="1.1101%" y="511.50"></text></g><g><title>EVP_CipherInit_ex (9 samples, 0.02%)</title><rect x="0.9064%" y="501" width="0.0232%" height="15" fill="rgb(226,26,5)" fg:x="352" fg:w="9"/><text x="1.1564%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (13 samples, 0.03%)</title><rect x="0.9296%" y="501" width="0.0335%" height="15" fill="rgb(249,33,26)" fg:x="361" fg:w="13"/><text x="1.1796%" y="511.50"></text></g><g><title>EVP_EncryptFinal_ex (5 samples, 0.01%)</title><rect x="0.9631%" y="501" width="0.0129%" height="15" fill="rgb(235,183,28)" fg:x="374" fg:w="5"/><text x="1.2131%" y="511.50"></text></g><g><title>OSSL_PARAM_locate (103 samples, 0.27%)</title><rect x="0.9914%" y="501" width="0.2652%" height="15" fill="rgb(221,5,38)" fg:x="385" fg:w="103"/><text x="1.2414%" y="511.50"></text></g><g><title>[benchmark] (6 samples, 0.02%)</title><rect x="1.2695%" y="501" width="0.0155%" height="15" fill="rgb(247,18,42)" fg:x="493" fg:w="6"/><text x="1.5195%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (6 samples, 0.02%)</title><rect x="1.2695%" y="485" width="0.0155%" height="15" fill="rgb(241,131,45)" fg:x="493" fg:w="6"/><text x="1.5195%" y="495.50"></text></g><g><title>[libc.so.6] (82 samples, 0.21%)</title><rect x="1.2850%" y="501" width="0.2112%" height="15" fill="rgb(249,31,29)" fg:x="499" fg:w="82"/><text x="1.5350%" y="511.50"></text></g><g><title>[libcrypto.so.3] (124 samples, 0.32%)</title><rect x="1.4962%" y="501" width="0.3193%" height="15" fill="rgb(225,111,53)" fg:x="581" fg:w="124"/><text x="1.7462%" y="511.50"></text></g><g><title>__lll_lock_wake_private (4 samples, 0.01%)</title><rect x="1.8206%" y="501" width="0.0103%" height="15" fill="rgb(238,160,17)" fg:x="707" fg:w="4"/><text x="2.0706%" y="511.50"></text></g><g><title>malloc (13 samples, 0.03%)</title><rect x="1.8464%" y="501" width="0.0335%" height="15" fill="rgb(214,148,48)" fg:x="717" fg:w="13"/><text x="2.0964%" y="511.50"></text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (5 samples, 0.01%)</title><rect x="1.8850%" y="501" width="0.0129%" height="15" fill="rgb(232,36,49)" fg:x="732" fg:w="5"/><text x="2.1350%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (8 samples, 0.02%)</title><rect x="1.9597%" y="485" width="0.0206%" height="15" fill="rgb(209,103,24)" fg:x="761" fg:w="8"/><text x="2.2097%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (14 samples, 0.04%)</title><rect x="1.9803%" y="485" width="0.0361%" height="15" fill="rgb(229,88,8)" fg:x="769" fg:w="14"/><text x="2.2303%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (53 samples, 0.14%)</title><rect x="1.9056%" y="501" width="0.1365%" height="15" fill="rgb(213,181,19)" fg:x="740" fg:w="53"/><text x="2.1556%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (10 samples, 0.03%)</title><rect x="2.0163%" y="485" width="0.0258%" height="15" fill="rgb(254,191,54)" fg:x="783" fg:w="10"/><text x="2.2663%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (8 samples, 0.02%)</title><rect x="2.0421%" y="501" width="0.0206%" height="15" fill="rgb(241,83,37)" fg:x="793" fg:w="8"/><text x="2.2921%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (5 samples, 0.01%)</title><rect x="2.0910%" y="485" width="0.0129%" height="15" fill="rgb(233,36,39)" fg:x="812" fg:w="5"/><text x="2.3410%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::try_recv (24 samples, 0.06%)</title><rect x="2.0627%" y="501" width="0.0618%" height="15" fill="rgb(226,3,54)" fg:x="801" fg:w="24"/><text x="2.3127%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (8 samples, 0.02%)</title><rect x="2.1039%" y="485" width="0.0206%" height="15" fill="rgb(245,192,40)" fg:x="817" fg:w="8"/><text x="2.3539%" y="495.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (9 samples, 0.02%)</title><rect x="2.1245%" y="501" width="0.0232%" height="15" fill="rgb(238,167,29)" fg:x="825" fg:w="9"/><text x="2.3745%" y="511.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (13 samples, 0.03%)</title><rect x="2.1477%" y="501" width="0.0335%" height="15" fill="rgb(232,182,51)" fg:x="834" fg:w="13"/><text x="2.3977%" y="511.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (8 samples, 0.02%)</title><rect x="2.1605%" y="485" width="0.0206%" height="15" fill="rgb(231,60,39)" fg:x="839" fg:w="8"/><text x="2.4105%" y="495.50"></text></g><g><title>core::sync::atomic::atomic_load (8 samples, 0.02%)</title><rect x="2.1605%" y="469" width="0.0206%" height="15" fill="rgb(208,69,12)" fg:x="839" fg:w="8"/><text x="2.4105%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (7 samples, 0.02%)</title><rect x="2.1811%" y="501" width="0.0180%" height="15" fill="rgb(235,93,37)" fg:x="847" fg:w="7"/><text x="2.4311%" y="511.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (4 samples, 0.01%)</title><rect x="2.2429%" y="485" width="0.0103%" height="15" fill="rgb(213,116,39)" fg:x="871" fg:w="4"/><text x="2.4929%" y="495.50"></text></g><g><title>std::time::Instant::duration_since (4 samples, 0.01%)</title><rect x="2.2429%" y="469" width="0.0103%" height="15" fill="rgb(222,207,29)" fg:x="871" fg:w="4"/><text x="2.4929%" y="479.50"></text></g><g><title>std::time::Instant::checked_duration_since (4 samples, 0.01%)</title><rect x="2.2429%" y="453" width="0.0103%" height="15" fill="rgb(206,96,30)" fg:x="871" fg:w="4"/><text x="2.4929%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (4 samples, 0.01%)</title><rect x="2.2429%" y="437" width="0.0103%" height="15" fill="rgb(218,138,4)" fg:x="871" fg:w="4"/><text x="2.4929%" y="447.50"></text></g><g><title>std::time::Instant::elapsed (21 samples, 0.05%)</title><rect x="2.2017%" y="501" width="0.0541%" height="15" fill="rgb(250,191,14)" fg:x="855" fg:w="21"/><text x="2.4517%" y="511.50"></text></g><g><title>syscall (12 samples, 0.03%)</title><rect x="2.2558%" y="501" width="0.0309%" height="15" fill="rgb(239,60,40)" fg:x="876" fg:w="12"/><text x="2.5058%" y="511.50"></text></g><g><title>__entry_text_start (10 samples, 0.03%)</title><rect x="2.2610%" y="485" width="0.0258%" height="15" fill="rgb(206,27,48)" fg:x="878" fg:w="10"/><text x="2.5110%" y="495.50"></text></g><g><title>[anon] (912 samples, 2.35%)</title><rect x="0.0052%" y="517" width="2.3485%" height="15" fill="rgb(225,35,8)" fg:x="2" fg:w="912"/><text x="0.2552%" y="527.50">[..</text></g><g><title>zssp::zeta::receive_payload_in_place (23 samples, 0.06%)</title><rect x="2.2944%" y="501" width="0.0592%" height="15" fill="rgb(250,213,24)" fg:x="891" fg:w="23"/><text x="2.5444%" y="511.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (5 samples, 0.01%)</title><rect x="2.3408%" y="485" width="0.0129%" height="15" fill="rgb(247,123,22)" fg:x="909" fg:w="5"/><text x="2.5908%" y="495.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (5 samples, 0.01%)</title><rect x="2.3408%" y="469" width="0.0129%" height="15" fill="rgb(231,138,38)" fg:x="909" fg:w="5"/><text x="2.5908%" y="479.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (5 samples, 0.01%)</title><rect x="2.3408%" y="453" width="0.0129%" height="15" fill="rgb(231,145,46)" fg:x="909" fg:w="5"/><text x="2.5908%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (5 samples, 0.01%)</title><rect x="2.3408%" y="437" width="0.0129%" height="15" fill="rgb(251,118,11)" fg:x="909" fg:w="5"/><text x="2.5908%" y="447.50"></text></g><g><title>[libc.so.6] (6 samples, 0.02%)</title><rect x="2.3537%" y="501" width="0.0155%" height="15" fill="rgb(217,147,25)" fg:x="914" fg:w="6"/><text x="2.6037%" y="511.50"></text></g><g><title>__rust_probestack (5 samples, 0.01%)</title><rect x="2.3691%" y="501" width="0.0129%" height="15" fill="rgb(247,81,37)" fg:x="920" fg:w="5"/><text x="2.6191%" y="511.50"></text></g><g><title>[benchmark] (38 samples, 0.10%)</title><rect x="2.3537%" y="517" width="0.0979%" height="15" fill="rgb(209,12,38)" fg:x="914" fg:w="38"/><text x="2.6037%" y="527.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (22 samples, 0.06%)</title><rect x="2.3949%" y="501" width="0.0567%" height="15" fill="rgb(227,1,9)" fg:x="930" fg:w="22"/><text x="2.6449%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (11 samples, 0.03%)</title><rect x="2.4824%" y="501" width="0.0283%" height="15" fill="rgb(248,47,43)" fg:x="964" fg:w="11"/><text x="2.7324%" y="511.50"></text></g><g><title>[libcrypto.so.3] (93 samples, 0.24%)</title><rect x="2.5185%" y="501" width="0.2395%" height="15" fill="rgb(221,10,30)" fg:x="978" fg:w="93"/><text x="2.7685%" y="511.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (5 samples, 0.01%)</title><rect x="2.7580%" y="501" width="0.0129%" height="15" fill="rgb(210,229,1)" fg:x="1071" fg:w="5"/><text x="3.0080%" y="511.50"></text></g><g><title>[libcrypto.so.3] (123 samples, 0.32%)</title><rect x="2.4567%" y="517" width="0.3167%" height="15" fill="rgb(222,148,37)" fg:x="954" fg:w="123"/><text x="2.7067%" y="527.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (20 samples, 0.05%)</title><rect x="2.7734%" y="501" width="0.0515%" height="15" fill="rgb(234,67,33)" fg:x="1077" fg:w="20"/><text x="3.0234%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::zero::ZeroToken as core::default::Default&gt;::default (7 samples, 0.02%)</title><rect x="2.8249%" y="501" width="0.0180%" height="15" fill="rgb(247,98,35)" fg:x="1097" fg:w="7"/><text x="3.0749%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (17 samples, 0.04%)</title><rect x="2.8429%" y="501" width="0.0438%" height="15" fill="rgb(247,138,52)" fg:x="1104" fg:w="17"/><text x="3.0929%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (14 samples, 0.04%)</title><rect x="2.8867%" y="501" width="0.0361%" height="15" fill="rgb(213,79,30)" fg:x="1121" fg:w="14"/><text x="3.1367%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (14 samples, 0.04%)</title><rect x="2.8867%" y="485" width="0.0361%" height="15" fill="rgb(246,177,23)" fg:x="1121" fg:w="14"/><text x="3.1367%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (5 samples, 0.01%)</title><rect x="2.9253%" y="501" width="0.0129%" height="15" fill="rgb(230,62,27)" fg:x="1136" fg:w="5"/><text x="3.1753%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (5 samples, 0.01%)</title><rect x="2.9253%" y="485" width="0.0129%" height="15" fill="rgb(216,154,8)" fg:x="1136" fg:w="5"/><text x="3.1753%" y="495.50"></text></g><g><title>CRYPTO_gcm128_decrypt (6 samples, 0.02%)</title><rect x="2.9408%" y="501" width="0.0155%" height="15" fill="rgb(244,35,45)" fg:x="1142" fg:w="6"/><text x="3.1908%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (25 samples, 0.06%)</title><rect x="2.9562%" y="501" width="0.0644%" height="15" fill="rgb(251,115,12)" fg:x="1148" fg:w="25"/><text x="3.2062%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt (18 samples, 0.05%)</title><rect x="3.0206%" y="501" width="0.0464%" height="15" fill="rgb(240,54,50)" fg:x="1173" fg:w="18"/><text x="3.2706%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (33 samples, 0.08%)</title><rect x="3.0670%" y="501" width="0.0850%" height="15" fill="rgb(233,84,52)" fg:x="1191" fg:w="33"/><text x="3.3170%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (4 samples, 0.01%)</title><rect x="3.1520%" y="501" width="0.0103%" height="15" fill="rgb(207,117,47)" fg:x="1224" fg:w="4"/><text x="3.4020%" y="511.50"></text></g><g><title>CRYPTO_gcm128_setiv (4 samples, 0.01%)</title><rect x="3.1623%" y="501" width="0.0103%" height="15" fill="rgb(249,43,39)" fg:x="1228" fg:w="4"/><text x="3.4123%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (16 samples, 0.04%)</title><rect x="3.1829%" y="501" width="0.0412%" height="15" fill="rgb(209,38,44)" fg:x="1236" fg:w="16"/><text x="3.4329%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (11 samples, 0.03%)</title><rect x="3.2241%" y="501" width="0.0283%" height="15" fill="rgb(236,212,23)" fg:x="1252" fg:w="11"/><text x="3.4741%" y="511.50"></text></g><g><title>EVP_CIPHER_get_block_size (4 samples, 0.01%)</title><rect x="3.2550%" y="501" width="0.0103%" height="15" fill="rgb(242,79,21)" fg:x="1264" fg:w="4"/><text x="3.5050%" y="511.50"></text></g><g><title>EVP_CipherInit_ex (4 samples, 0.01%)</title><rect x="3.2653%" y="501" width="0.0103%" height="15" fill="rgb(211,96,35)" fg:x="1268" fg:w="4"/><text x="3.5153%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (46 samples, 0.12%)</title><rect x="3.2781%" y="501" width="0.1185%" height="15" fill="rgb(253,215,40)" fg:x="1273" fg:w="46"/><text x="3.5281%" y="511.50"></text></g><g><title>EVP_EncryptUpdate (45 samples, 0.12%)</title><rect x="3.3966%" y="501" width="0.1159%" height="15" fill="rgb(211,81,21)" fg:x="1319" fg:w="45"/><text x="3.6466%" y="511.50"></text></g><g><title>OSSL_PARAM_locate (33 samples, 0.08%)</title><rect x="3.5125%" y="501" width="0.0850%" height="15" fill="rgb(208,190,38)" fg:x="1364" fg:w="33"/><text x="3.7625%" y="511.50"></text></g><g><title>[[vdso]] (16 samples, 0.04%)</title><rect x="3.6026%" y="501" width="0.0412%" height="15" fill="rgb(235,213,38)" fg:x="1399" fg:w="16"/><text x="3.8526%" y="511.50"></text></g><g><title>[benchmark] (9 samples, 0.02%)</title><rect x="3.6438%" y="501" width="0.0232%" height="15" fill="rgb(237,122,38)" fg:x="1415" fg:w="9"/><text x="3.8938%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (9 samples, 0.02%)</title><rect x="3.6438%" y="485" width="0.0232%" height="15" fill="rgb(244,218,35)" fg:x="1415" fg:w="9"/><text x="3.8938%" y="495.50"></text></g><g><title>[libc.so.6] (73 samples, 0.19%)</title><rect x="3.6670%" y="501" width="0.1880%" height="15" fill="rgb(240,68,47)" fg:x="1424" fg:w="73"/><text x="3.9170%" y="511.50"></text></g><g><title>[libcrypto.so.3] (329 samples, 0.85%)</title><rect x="3.8550%" y="501" width="0.8472%" height="15" fill="rgb(210,16,53)" fg:x="1497" fg:w="329"/><text x="4.1050%" y="511.50"></text></g><g><title>__bss_start (20 samples, 0.05%)</title><rect x="4.7022%" y="501" width="0.0515%" height="15" fill="rgb(235,124,12)" fg:x="1826" fg:w="20"/><text x="4.9522%" y="511.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="4.7022%" y="485" width="0.0515%" height="15" fill="rgb(224,169,11)" fg:x="1826" fg:w="20"/><text x="4.9522%" y="495.50"></text></g><g><title>__lll_lock_wait_private (4 samples, 0.01%)</title><rect x="4.7537%" y="501" width="0.0103%" height="15" fill="rgb(250,166,2)" fg:x="1846" fg:w="4"/><text x="5.0037%" y="511.50"></text></g><g><title>__entry_text_start (35 samples, 0.09%)</title><rect x="5.1142%" y="309" width="0.0901%" height="15" fill="rgb(242,216,29)" fg:x="1986" fg:w="35"/><text x="5.3642%" y="319.50"></text></g><g><title>crng_make_state (5 samples, 0.01%)</title><rect x="5.2636%" y="261" width="0.0129%" height="15" fill="rgb(230,116,27)" fg:x="2044" fg:w="5"/><text x="5.5136%" y="271.50"></text></g><g><title>_copy_to_iter (38 samples, 0.10%)</title><rect x="5.3769%" y="245" width="0.0979%" height="15" fill="rgb(228,99,48)" fg:x="2088" fg:w="38"/><text x="5.6269%" y="255.50"></text></g><g><title>copyout (28 samples, 0.07%)</title><rect x="5.4026%" y="229" width="0.0721%" height="15" fill="rgb(253,11,6)" fg:x="2098" fg:w="28"/><text x="5.6526%" y="239.50"></text></g><g><title>copyout (5 samples, 0.01%)</title><rect x="5.4747%" y="245" width="0.0129%" height="15" fill="rgb(247,143,39)" fg:x="2126" fg:w="5"/><text x="5.7247%" y="255.50"></text></g><g><title>__memcpy (14 samples, 0.04%)</title><rect x="5.5571%" y="229" width="0.0361%" height="15" fill="rgb(236,97,10)" fg:x="2158" fg:w="14"/><text x="5.8071%" y="239.50"></text></g><g><title>chacha_block_generic (267 samples, 0.69%)</title><rect x="5.6859%" y="213" width="0.6876%" height="15" fill="rgb(233,208,19)" fg:x="2208" fg:w="267"/><text x="5.9359%" y="223.50"></text></g><g><title>chacha_permute (242 samples, 0.62%)</title><rect x="5.7503%" y="197" width="0.6232%" height="15" fill="rgb(216,164,2)" fg:x="2233" fg:w="242"/><text x="6.0003%" y="207.50"></text></g><g><title>__x64_sys_getrandom (440 samples, 1.13%)</title><rect x="5.2455%" y="277" width="1.1331%" height="15" fill="rgb(220,129,5)" fg:x="2037" fg:w="440"/><text x="5.4955%" y="287.50"></text></g><g><title>get_random_bytes_user (428 samples, 1.10%)</title><rect x="5.2764%" y="261" width="1.1022%" height="15" fill="rgb(242,17,10)" fg:x="2049" fg:w="428"/><text x="5.5264%" y="271.50"></text></g><g><title>crng_make_state (343 samples, 0.88%)</title><rect x="5.4953%" y="245" width="0.8833%" height="15" fill="rgb(242,107,0)" fg:x="2134" fg:w="343"/><text x="5.7453%" y="255.50"></text></g><g><title>crng_fast_key_erasure (302 samples, 0.78%)</title><rect x="5.6009%" y="229" width="0.7777%" height="15" fill="rgb(251,28,31)" fg:x="2175" fg:w="302"/><text x="5.8509%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (19 samples, 0.05%)</title><rect x="6.4069%" y="261" width="0.0489%" height="15" fill="rgb(233,223,10)" fg:x="2488" fg:w="19"/><text x="6.6569%" y="271.50"></text></g><g><title>do_syscall_64 (474 samples, 1.22%)</title><rect x="5.2430%" y="293" width="1.2206%" height="15" fill="rgb(215,21,27)" fg:x="2036" fg:w="474"/><text x="5.4930%" y="303.50"></text></g><g><title>syscall_exit_to_user_mode (24 samples, 0.06%)</title><rect x="6.4018%" y="277" width="0.0618%" height="15" fill="rgb(232,23,21)" fg:x="2486" fg:w="24"/><text x="6.6518%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (494 samples, 1.27%)</title><rect x="5.2095%" y="309" width="1.2721%" height="15" fill="rgb(244,5,23)" fg:x="2023" fg:w="494"/><text x="5.4595%" y="319.50"></text></g><g><title>syscall_exit_to_user_mode (4 samples, 0.01%)</title><rect x="6.4713%" y="293" width="0.0103%" height="15" fill="rgb(226,81,46)" fg:x="2513" fg:w="4"/><text x="6.7213%" y="303.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::next_u64 (593 samples, 1.53%)</title><rect x="4.9777%" y="485" width="1.5271%" height="15" fill="rgb(247,70,30)" fg:x="1933" fg:w="593"/><text x="5.2277%" y="495.50"></text></g><g><title>rand_core::impls::next_u64_via_fill (593 samples, 1.53%)</title><rect x="4.9777%" y="469" width="1.5271%" height="15" fill="rgb(212,68,19)" fg:x="1933" fg:w="593"/><text x="5.2277%" y="479.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::fill_bytes (593 samples, 1.53%)</title><rect x="4.9777%" y="453" width="1.5271%" height="15" fill="rgb(240,187,13)" fg:x="1933" fg:w="593"/><text x="5.2277%" y="463.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::try_fill_bytes (587 samples, 1.51%)</title><rect x="4.9932%" y="437" width="1.5116%" height="15" fill="rgb(223,113,26)" fg:x="1939" fg:w="587"/><text x="5.2432%" y="447.50"></text></g><g><title>getrandom::getrandom (587 samples, 1.51%)</title><rect x="4.9932%" y="421" width="1.5116%" height="15" fill="rgb(206,192,2)" fg:x="1939" fg:w="587"/><text x="5.2432%" y="431.50"></text></g><g><title>getrandom::getrandom_uninit (587 samples, 1.51%)</title><rect x="4.9932%" y="405" width="1.5116%" height="15" fill="rgb(241,108,4)" fg:x="1939" fg:w="587"/><text x="5.2432%" y="415.50"></text></g><g><title>getrandom::imp::getrandom_inner (586 samples, 1.51%)</title><rect x="4.9958%" y="389" width="1.5090%" height="15" fill="rgb(247,173,49)" fg:x="1940" fg:w="586"/><text x="5.2458%" y="399.50"></text></g><g><title>getrandom::util_libc::sys_fill_exact (583 samples, 1.50%)</title><rect x="5.0035%" y="373" width="1.5013%" height="15" fill="rgb(224,114,35)" fg:x="1943" fg:w="583"/><text x="5.2535%" y="383.50"></text></g><g><title>getrandom::imp::getrandom_inner::_{{closure}} (577 samples, 1.49%)</title><rect x="5.0189%" y="357" width="1.4858%" height="15" fill="rgb(245,159,27)" fg:x="1949" fg:w="577"/><text x="5.2689%" y="367.50"></text></g><g><title>getrandom::imp::getrandom (577 samples, 1.49%)</title><rect x="5.0189%" y="341" width="1.4858%" height="15" fill="rgb(245,172,44)" fg:x="1949" fg:w="577"/><text x="5.2689%" y="351.50"></text></g><g><title>syscall (575 samples, 1.48%)</title><rect x="5.0241%" y="325" width="1.4807%" height="15" fill="rgb(236,23,11)" fg:x="1951" fg:w="575"/><text x="5.2741%" y="335.50"></text></g><g><title>syscall_return_via_sysret (9 samples, 0.02%)</title><rect x="6.4816%" y="309" width="0.0232%" height="15" fill="rgb(205,117,38)" fg:x="2517" fg:w="9"/><text x="6.7316%" y="319.50"></text></g><g><title>[libc.so.6] (20 samples, 0.05%)</title><rect x="6.5048%" y="485" width="0.0515%" height="15" fill="rgb(237,72,25)" fg:x="2526" fg:w="20"/><text x="6.7548%" y="495.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (7 samples, 0.02%)</title><rect x="6.5563%" y="485" width="0.0180%" height="15" fill="rgb(244,70,9)" fg:x="2546" fg:w="7"/><text x="6.8063%" y="495.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (7 samples, 0.02%)</title><rect x="6.5563%" y="469" width="0.0180%" height="15" fill="rgb(217,125,39)" fg:x="2546" fg:w="7"/><text x="6.8063%" y="479.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (7 samples, 0.02%)</title><rect x="6.5563%" y="453" width="0.0180%" height="15" fill="rgb(235,36,10)" fg:x="2546" fg:w="7"/><text x="6.8063%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (12 samples, 0.03%)</title><rect x="6.5872%" y="485" width="0.0309%" height="15" fill="rgb(251,123,47)" fg:x="2558" fg:w="12"/><text x="6.8372%" y="495.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (12 samples, 0.03%)</title><rect x="6.5872%" y="469" width="0.0309%" height="15" fill="rgb(221,13,13)" fg:x="2558" fg:w="12"/><text x="6.8372%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (12 samples, 0.03%)</title><rect x="6.5872%" y="453" width="0.0309%" height="15" fill="rgb(238,131,9)" fg:x="2558" fg:w="12"/><text x="6.8372%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_sub (12 samples, 0.03%)</title><rect x="6.5872%" y="437" width="0.0309%" height="15" fill="rgb(211,50,8)" fg:x="2558" fg:w="12"/><text x="6.8372%" y="447.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (5 samples, 0.01%)</title><rect x="6.6902%" y="437" width="0.0129%" height="15" fill="rgb(245,182,24)" fg:x="2598" fg:w="5"/><text x="6.9402%" y="447.50"></text></g><g><title>_ZN3std4sync4mpmc5array16Channel$LT$T$GT$10start_recv17h7800ca29c64cb868E.llvm.12455019271255371362 (9 samples, 0.02%)</title><rect x="6.7031%" y="437" width="0.0232%" height="15" fill="rgb(242,14,37)" fg:x="2603" fg:w="9"/><text x="6.9531%" y="447.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init (20 samples, 0.05%)</title><rect x="6.7340%" y="421" width="0.0515%" height="15" fill="rgb(246,228,12)" fg:x="2615" fg:w="20"/><text x="6.9840%" y="431.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (25 samples, 0.06%)</title><rect x="6.7340%" y="437" width="0.0644%" height="15" fill="rgb(213,55,15)" fg:x="2615" fg:w="25"/><text x="6.9840%" y="447.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (5 samples, 0.01%)</title><rect x="6.7855%" y="421" width="0.0129%" height="15" fill="rgb(209,9,3)" fg:x="2635" fg:w="5"/><text x="7.0355%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (44 samples, 0.11%)</title><rect x="6.8936%" y="421" width="0.1133%" height="15" fill="rgb(230,59,30)" fg:x="2677" fg:w="44"/><text x="7.1436%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (44 samples, 0.11%)</title><rect x="6.8936%" y="405" width="0.1133%" height="15" fill="rgb(209,121,21)" fg:x="2677" fg:w="44"/><text x="7.1436%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (177 samples, 0.46%)</title><rect x="7.0069%" y="421" width="0.4558%" height="15" fill="rgb(220,109,13)" fg:x="2721" fg:w="177"/><text x="7.2569%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_load (177 samples, 0.46%)</title><rect x="7.0069%" y="405" width="0.4558%" height="15" fill="rgb(232,18,1)" fg:x="2721" fg:w="177"/><text x="7.2569%" y="415.50"></text></g><g><title>core::sync::atomic::fence (10 samples, 0.03%)</title><rect x="7.4627%" y="421" width="0.0258%" height="15" fill="rgb(215,41,42)" fg:x="2898" fg:w="10"/><text x="7.7127%" y="431.50"></text></g><g><title>std::sync::mpsc::Receiver&lt;T&gt;::try_recv (337 samples, 0.87%)</title><rect x="6.6258%" y="485" width="0.8678%" height="15" fill="rgb(224,123,36)" fg:x="2573" fg:w="337"/><text x="6.8758%" y="495.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::try_recv (337 samples, 0.87%)</title><rect x="6.6258%" y="469" width="0.8678%" height="15" fill="rgb(240,125,3)" fg:x="2573" fg:w="337"/><text x="6.8758%" y="479.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::try_recv (326 samples, 0.84%)</title><rect x="6.6541%" y="453" width="0.8395%" height="15" fill="rgb(205,98,50)" fg:x="2584" fg:w="326"/><text x="6.9041%" y="463.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (270 samples, 0.70%)</title><rect x="6.7983%" y="437" width="0.6953%" height="15" fill="rgb(205,185,37)" fg:x="2640" fg:w="270"/><text x="7.0483%" y="447.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (8 samples, 0.02%)</title><rect x="7.4936%" y="469" width="0.0206%" height="15" fill="rgb(238,207,15)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="479.50"></text></g><g><title>std::time::Instant::duration_since (8 samples, 0.02%)</title><rect x="7.4936%" y="453" width="0.0206%" height="15" fill="rgb(213,199,42)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="463.50"></text></g><g><title>std::time::Instant::checked_duration_since (8 samples, 0.02%)</title><rect x="7.4936%" y="437" width="0.0206%" height="15" fill="rgb(235,201,11)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (8 samples, 0.02%)</title><rect x="7.4936%" y="421" width="0.0206%" height="15" fill="rgb(207,46,11)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="431.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (8 samples, 0.02%)</title><rect x="7.4936%" y="405" width="0.0206%" height="15" fill="rgb(241,35,35)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="415.50"></text></g><g><title>[[vdso]] (33 samples, 0.08%)</title><rect x="7.5194%" y="405" width="0.0850%" height="15" fill="rgb(243,32,47)" fg:x="2920" fg:w="33"/><text x="7.7694%" y="415.50"></text></g><g><title>[[vdso]] (19 samples, 0.05%)</title><rect x="7.5554%" y="389" width="0.0489%" height="15" fill="rgb(247,202,23)" fg:x="2934" fg:w="19"/><text x="7.8054%" y="399.50"></text></g><g><title>std::time::Instant::elapsed (44 samples, 0.11%)</title><rect x="7.4936%" y="485" width="0.1133%" height="15" fill="rgb(219,102,11)" fg:x="2910" fg:w="44"/><text x="7.7436%" y="495.50"></text></g><g><title>std::time::Instant::now (36 samples, 0.09%)</title><rect x="7.5142%" y="469" width="0.0927%" height="15" fill="rgb(243,110,44)" fg:x="2918" fg:w="36"/><text x="7.7642%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::Instant::now (36 samples, 0.09%)</title><rect x="7.5142%" y="453" width="0.0927%" height="15" fill="rgb(222,74,54)" fg:x="2918" fg:w="36"/><text x="7.7642%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (35 samples, 0.09%)</title><rect x="7.5168%" y="437" width="0.0901%" height="15" fill="rgb(216,99,12)" fg:x="2919" fg:w="35"/><text x="7.7668%" y="447.50"></text></g><g><title>clock_gettime (35 samples, 0.09%)</title><rect x="7.5168%" y="421" width="0.0901%" height="15" fill="rgb(226,22,26)" fg:x="2919" fg:w="35"/><text x="7.7668%" y="431.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (401 samples, 1.03%)</title><rect x="7.8361%" y="469" width="1.0326%" height="15" fill="rgb(217,163,10)" fg:x="3043" fg:w="401"/><text x="8.0861%" y="479.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (401 samples, 1.03%)</title><rect x="7.8361%" y="453" width="1.0326%" height="15" fill="rgb(213,25,53)" fg:x="3043" fg:w="401"/><text x="8.0861%" y="463.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (401 samples, 1.03%)</title><rect x="7.8361%" y="437" width="1.0326%" height="15" fill="rgb(252,105,26)" fg:x="3043" fg:w="401"/><text x="8.0861%" y="447.50"></text></g><g><title>&lt;core::result::Result&lt;T,E&gt; as core::ops::try_trait::Try&gt;::branch (4 samples, 0.01%)</title><rect x="8.8687%" y="469" width="0.0103%" height="15" fill="rgb(220,39,43)" fg:x="3444" fg:w="4"/><text x="9.1187%" y="479.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (5 samples, 0.01%)</title><rect x="8.8971%" y="421" width="0.0129%" height="15" fill="rgb(229,68,48)" fg:x="3455" fg:w="5"/><text x="9.1471%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (71 samples, 0.18%)</title><rect x="8.8971%" y="453" width="0.1828%" height="15" fill="rgb(252,8,32)" fg:x="3455" fg:w="71"/><text x="9.1471%" y="463.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (71 samples, 0.18%)</title><rect x="8.8971%" y="437" width="0.1828%" height="15" fill="rgb(223,20,43)" fg:x="3455" fg:w="71"/><text x="9.1471%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (64 samples, 0.16%)</title><rect x="8.9151%" y="421" width="0.1648%" height="15" fill="rgb(229,81,49)" fg:x="3462" fg:w="64"/><text x="9.1651%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (60 samples, 0.15%)</title><rect x="8.9254%" y="405" width="0.1545%" height="15" fill="rgb(236,28,36)" fg:x="3466" fg:w="60"/><text x="9.1754%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_swap (60 samples, 0.15%)</title><rect x="8.9254%" y="389" width="0.1545%" height="15" fill="rgb(249,185,26)" fg:x="3466" fg:w="60"/><text x="9.1754%" y="399.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (5 samples, 0.01%)</title><rect x="9.0799%" y="437" width="0.0129%" height="15" fill="rgb(249,174,33)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="447.50"></text></g><g><title>std::sync::poison::Flag::guard (5 samples, 0.01%)</title><rect x="9.0799%" y="421" width="0.0129%" height="15" fill="rgb(233,201,37)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="431.50"></text></g><g><title>std::thread::panicking (5 samples, 0.01%)</title><rect x="9.0799%" y="405" width="0.0129%" height="15" fill="rgb(221,78,26)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="415.50"></text></g><g><title>std::panicking::panicking (5 samples, 0.01%)</title><rect x="9.0799%" y="389" width="0.0129%" height="15" fill="rgb(250,127,30)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="399.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (5 samples, 0.01%)</title><rect x="9.0799%" y="373" width="0.0129%" height="15" fill="rgb(230,49,44)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (77 samples, 0.20%)</title><rect x="9.0799%" y="453" width="0.1983%" height="15" fill="rgb(229,67,23)" fg:x="3526" fg:w="77"/><text x="9.3299%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (72 samples, 0.19%)</title><rect x="9.0928%" y="437" width="0.1854%" height="15" fill="rgb(249,83,47)" fg:x="3531" fg:w="72"/><text x="9.3428%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (70 samples, 0.18%)</title><rect x="9.0979%" y="421" width="0.1803%" height="15" fill="rgb(215,43,3)" fg:x="3533" fg:w="70"/><text x="9.3479%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (70 samples, 0.18%)</title><rect x="9.0979%" y="405" width="0.1803%" height="15" fill="rgb(238,154,13)" fg:x="3533" fg:w="70"/><text x="9.3479%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_get_block_size (5 samples, 0.01%)</title><rect x="9.3657%" y="421" width="0.0129%" height="15" fill="rgb(219,56,2)" fg:x="3637" fg:w="5"/><text x="9.6157%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (394 samples, 1.01%)</title><rect x="8.8893%" y="469" width="1.0146%" height="15" fill="rgb(233,0,4)" fg:x="3452" fg:w="394"/><text x="9.1393%" y="479.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (243 samples, 0.63%)</title><rect x="9.2782%" y="453" width="0.6258%" height="15" fill="rgb(235,30,7)" fg:x="3603" fg:w="243"/><text x="9.5282%" y="463.50"></text></g><g><title>EVP_DecryptUpdate (242 samples, 0.62%)</title><rect x="9.2808%" y="437" width="0.6232%" height="15" fill="rgb(250,79,13)" fg:x="3604" fg:w="242"/><text x="9.5308%" y="447.50"></text></g><g><title>[libcrypto.so.3] (204 samples, 0.53%)</title><rect x="9.3786%" y="421" width="0.5253%" height="15" fill="rgb(211,146,34)" fg:x="3642" fg:w="204"/><text x="9.6286%" y="431.50"></text></g><g><title>[libcrypto.so.3] (152 samples, 0.39%)</title><rect x="9.5125%" y="405" width="0.3914%" height="15" fill="rgb(228,22,38)" fg:x="3694" fg:w="152"/><text x="9.7625%" y="415.50"></text></g><g><title>[libcrypto.so.3] (144 samples, 0.37%)</title><rect x="9.5331%" y="389" width="0.3708%" height="15" fill="rgb(235,168,5)" fg:x="3702" fg:w="144"/><text x="9.7831%" y="399.50"></text></g><g><title>__rust_probestack (9 samples, 0.02%)</title><rect x="9.9039%" y="469" width="0.0232%" height="15" fill="rgb(221,155,16)" fg:x="3846" fg:w="9"/><text x="10.1539%" y="479.50"></text></g><g><title>core::cmp::Ord::max (4 samples, 0.01%)</title><rect x="9.9323%" y="469" width="0.0103%" height="15" fill="rgb(215,215,53)" fg:x="3857" fg:w="4"/><text x="10.1823%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (4 samples, 0.01%)</title><rect x="9.9323%" y="453" width="0.0103%" height="15" fill="rgb(223,4,10)" fg:x="3857" fg:w="4"/><text x="10.1823%" y="463.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="9.9503%" y="293" width="0.0129%" height="15" fill="rgb(234,103,6)" fg:x="3864" fg:w="5"/><text x="10.2003%" y="303.50"></text></g><g><title>core::num::nonzero::NonZeroU32::new (13 samples, 0.03%)</title><rect x="9.9426%" y="469" width="0.0335%" height="15" fill="rgb(227,97,0)" fg:x="3861" fg:w="13"/><text x="10.1926%" y="479.50"></text></g><g><title>asm_sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="9.9503%" y="453" width="0.0258%" height="15" fill="rgb(234,150,53)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="463.50"></text></g><g><title>sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="9.9503%" y="437" width="0.0258%" height="15" fill="rgb(228,201,54)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="447.50"></text></g><g><title>irqentry_exit (10 samples, 0.03%)</title><rect x="9.9503%" y="421" width="0.0258%" height="15" fill="rgb(222,22,37)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="431.50"></text></g><g><title>irqentry_exit_to_user_mode (10 samples, 0.03%)</title><rect x="9.9503%" y="405" width="0.0258%" height="15" fill="rgb(237,53,32)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="415.50"></text></g><g><title>exit_to_user_mode_prepare (10 samples, 0.03%)</title><rect x="9.9503%" y="389" width="0.0258%" height="15" fill="rgb(233,25,53)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="399.50"></text></g><g><title>exit_to_user_mode_loop (10 samples, 0.03%)</title><rect x="9.9503%" y="373" width="0.0258%" height="15" fill="rgb(210,40,34)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="383.50"></text></g><g><title>schedule (10 samples, 0.03%)</title><rect x="9.9503%" y="357" width="0.0258%" height="15" fill="rgb(241,220,44)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="367.50"></text></g><g><title>__schedule (10 samples, 0.03%)</title><rect x="9.9503%" y="341" width="0.0258%" height="15" fill="rgb(235,28,35)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="351.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="9.9503%" y="325" width="0.0258%" height="15" fill="rgb(210,56,17)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="335.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="9.9503%" y="309" width="0.0258%" height="15" fill="rgb(224,130,29)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="319.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="9.9632%" y="293" width="0.0129%" height="15" fill="rgb(235,212,8)" fg:x="3869" fg:w="5"/><text x="10.2132%" y="303.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade::_{{closure}} (9 samples, 0.02%)</title><rect x="9.9941%" y="405" width="0.0232%" height="15" fill="rgb(223,33,50)" fg:x="3881" fg:w="9"/><text x="10.2441%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (61 samples, 0.16%)</title><rect x="10.0173%" y="405" width="0.1571%" height="15" fill="rgb(219,149,13)" fg:x="3890" fg:w="61"/><text x="10.2673%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (61 samples, 0.16%)</title><rect x="10.0173%" y="389" width="0.1571%" height="15" fill="rgb(250,156,29)" fg:x="3890" fg:w="61"/><text x="10.2673%" y="399.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade (81 samples, 0.21%)</title><rect x="9.9761%" y="437" width="0.2086%" height="15" fill="rgb(216,193,19)" fg:x="3874" fg:w="81"/><text x="10.2261%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_update (78 samples, 0.20%)</title><rect x="9.9838%" y="421" width="0.2009%" height="15" fill="rgb(216,135,14)" fg:x="3877" fg:w="78"/><text x="10.2338%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (4 samples, 0.01%)</title><rect x="10.1743%" y="405" width="0.0103%" height="15" fill="rgb(241,47,5)" fg:x="3951" fg:w="4"/><text x="10.4243%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (4 samples, 0.01%)</title><rect x="10.1743%" y="389" width="0.0103%" height="15" fill="rgb(233,42,35)" fg:x="3951" fg:w="4"/><text x="10.4243%" y="399.50"></text></g><g><title>core::option::Option&lt;T&gt;::map (82 samples, 0.21%)</title><rect x="9.9761%" y="469" width="0.2112%" height="15" fill="rgb(231,13,6)" fg:x="3874" fg:w="82"/><text x="10.2261%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive::_{{closure}} (82 samples, 0.21%)</title><rect x="9.9761%" y="453" width="0.2112%" height="15" fill="rgb(207,181,40)" fg:x="3874" fg:w="82"/><text x="10.2261%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (55 samples, 0.14%)</title><rect x="10.1872%" y="469" width="0.1416%" height="15" fill="rgb(254,173,49)" fg:x="3956" fg:w="55"/><text x="10.4372%" y="479.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (55 samples, 0.14%)</title><rect x="10.1872%" y="453" width="0.1416%" height="15" fill="rgb(221,1,38)" fg:x="3956" fg:w="55"/><text x="10.4372%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (53 samples, 0.14%)</title><rect x="10.1924%" y="437" width="0.1365%" height="15" fill="rgb(206,124,46)" fg:x="3958" fg:w="53"/><text x="10.4424%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_sub (53 samples, 0.14%)</title><rect x="10.1924%" y="421" width="0.1365%" height="15" fill="rgb(249,21,11)" fg:x="3958" fg:w="53"/><text x="10.4424%" y="431.50"></text></g><g><title>__rdl_dealloc (4 samples, 0.01%)</title><rect x="10.3494%" y="293" width="0.0103%" height="15" fill="rgb(222,201,40)" fg:x="4019" fg:w="4"/><text x="10.5994%" y="303.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::dealloc (4 samples, 0.01%)</title><rect x="10.3494%" y="277" width="0.0103%" height="15" fill="rgb(235,61,29)" fg:x="4019" fg:w="4"/><text x="10.5994%" y="287.50"></text></g><g><title>__rust_dealloc (5 samples, 0.01%)</title><rect x="10.3597%" y="293" width="0.0129%" height="15" fill="rgb(219,207,3)" fg:x="4023" fg:w="5"/><text x="10.6097%" y="303.50"></text></g><g><title>[libc.so.6] (48 samples, 0.12%)</title><rect x="11.5134%" y="261" width="0.1236%" height="15" fill="rgb(222,56,46)" fg:x="4471" fg:w="48"/><text x="11.7634%" y="271.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="11.6241%" y="245" width="0.0129%" height="15" fill="rgb(239,76,54)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="255.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="11.6241%" y="229" width="0.0129%" height="15" fill="rgb(231,124,27)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="239.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="11.6241%" y="213" width="0.0129%" height="15" fill="rgb(249,195,6)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="223.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="11.6241%" y="197" width="0.0129%" height="15" fill="rgb(237,174,47)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="11.6241%" y="181" width="0.0129%" height="15" fill="rgb(206,201,31)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="191.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="11.6241%" y="165" width="0.0129%" height="15" fill="rgb(231,57,52)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="175.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="11.6241%" y="149" width="0.0129%" height="15" fill="rgb(248,177,22)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="159.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="11.6241%" y="133" width="0.0129%" height="15" fill="rgb(215,211,37)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="11.6241%" y="117" width="0.0129%" height="15" fill="rgb(241,128,51)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="11.6241%" y="101" width="0.0129%" height="15" fill="rgb(227,165,31)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="111.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="11.6241%" y="85" width="0.0129%" height="15" fill="rgb(228,167,24)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="95.50"></text></g><g><title>__entry_text_start (14 samples, 0.04%)</title><rect x="11.7503%" y="245" width="0.0361%" height="15" fill="rgb(228,143,12)" fg:x="4563" fg:w="14"/><text x="12.0003%" y="255.50"></text></g><g><title>futex_unqueue (10 samples, 0.03%)</title><rect x="11.8662%" y="165" width="0.0258%" height="15" fill="rgb(249,149,8)" fg:x="4608" fg:w="10"/><text x="12.1162%" y="175.50"></text></g><g><title>update_curr (11 samples, 0.03%)</title><rect x="12.0104%" y="69" width="0.0283%" height="15" fill="rgb(243,35,44)" fg:x="4664" fg:w="11"/><text x="12.2604%" y="79.50"></text></g><g><title>cpuacct_charge (5 samples, 0.01%)</title><rect x="12.0259%" y="53" width="0.0129%" height="15" fill="rgb(246,89,9)" fg:x="4670" fg:w="5"/><text x="12.2759%" y="63.50"></text></g><g><title>update_load_avg (8 samples, 0.02%)</title><rect x="12.0387%" y="69" width="0.0206%" height="15" fill="rgb(233,213,13)" fg:x="4675" fg:w="8"/><text x="12.2887%" y="79.50"></text></g><g><title>dequeue_entity (28 samples, 0.07%)</title><rect x="11.9898%" y="85" width="0.0721%" height="15" fill="rgb(233,141,41)" fg:x="4656" fg:w="28"/><text x="12.2398%" y="95.50"></text></g><g><title>dequeue_task (37 samples, 0.10%)</title><rect x="11.9744%" y="117" width="0.0953%" height="15" fill="rgb(239,167,4)" fg:x="4650" fg:w="37"/><text x="12.2244%" y="127.50"></text></g><g><title>dequeue_task_fair (36 samples, 0.09%)</title><rect x="11.9769%" y="101" width="0.0927%" height="15" fill="rgb(209,217,16)" fg:x="4651" fg:w="36"/><text x="12.2269%" y="111.50"></text></g><g><title>__perf_event_task_sched_in (8 samples, 0.02%)</title><rect x="12.0722%" y="101" width="0.0206%" height="15" fill="rgb(219,88,35)" fg:x="4688" fg:w="8"/><text x="12.3222%" y="111.50"></text></g><g><title>perf_ctx_enable (8 samples, 0.02%)</title><rect x="12.0722%" y="85" width="0.0206%" height="15" fill="rgb(220,193,23)" fg:x="4688" fg:w="8"/><text x="12.3222%" y="95.50"></text></g><g><title>finish_task_switch.isra.0 (18 samples, 0.05%)</title><rect x="12.0696%" y="117" width="0.0464%" height="15" fill="rgb(230,90,52)" fg:x="4687" fg:w="18"/><text x="12.3196%" y="127.50"></text></g><g><title>raw_spin_rq_unlock (9 samples, 0.02%)</title><rect x="12.0928%" y="101" width="0.0232%" height="15" fill="rgb(252,106,19)" fg:x="4696" fg:w="9"/><text x="12.3428%" y="111.50"></text></g><g><title>pick_next_task_fair (4 samples, 0.01%)</title><rect x="12.1237%" y="101" width="0.0103%" height="15" fill="rgb(206,74,20)" fg:x="4708" fg:w="4"/><text x="12.3737%" y="111.50"></text></g><g><title>newidle_balance (4 samples, 0.01%)</title><rect x="12.1237%" y="85" width="0.0103%" height="15" fill="rgb(230,138,44)" fg:x="4708" fg:w="4"/><text x="12.3737%" y="95.50"></text></g><g><title>pick_next_task (11 samples, 0.03%)</title><rect x="12.1160%" y="117" width="0.0283%" height="15" fill="rgb(235,182,43)" fg:x="4705" fg:w="11"/><text x="12.3660%" y="127.50"></text></g><g><title>prepare_task_switch (14 samples, 0.04%)</title><rect x="12.1469%" y="117" width="0.0361%" height="15" fill="rgb(242,16,51)" fg:x="4717" fg:w="14"/><text x="12.3969%" y="127.50"></text></g><g><title>__perf_event_task_sched_out (5 samples, 0.01%)</title><rect x="12.1701%" y="101" width="0.0129%" height="15" fill="rgb(248,9,4)" fg:x="4726" fg:w="5"/><text x="12.4201%" y="111.50"></text></g><g><title>psi_group_change (26 samples, 0.07%)</title><rect x="12.2216%" y="101" width="0.0670%" height="15" fill="rgb(210,31,22)" fg:x="4746" fg:w="26"/><text x="12.4716%" y="111.50"></text></g><g><title>psi_task_switch (44 samples, 0.11%)</title><rect x="12.1881%" y="117" width="0.1133%" height="15" fill="rgb(239,54,39)" fg:x="4733" fg:w="44"/><text x="12.4381%" y="127.50"></text></g><g><title>__schedule (149 samples, 0.38%)</title><rect x="11.9280%" y="133" width="0.3837%" height="15" fill="rgb(230,99,41)" fg:x="4632" fg:w="149"/><text x="12.1780%" y="143.50"></text></g><g><title>futex_wait_queue (165 samples, 0.42%)</title><rect x="11.8919%" y="165" width="0.4249%" height="15" fill="rgb(253,106,12)" fg:x="4618" fg:w="165"/><text x="12.1419%" y="175.50"></text></g><g><title>schedule (159 samples, 0.41%)</title><rect x="11.9074%" y="149" width="0.4094%" height="15" fill="rgb(213,46,41)" fg:x="4624" fg:w="159"/><text x="12.1574%" y="159.50"></text></g><g><title>__get_user_nocheck_4 (16 samples, 0.04%)</title><rect x="12.3297%" y="149" width="0.0412%" height="15" fill="rgb(215,133,35)" fg:x="4788" fg:w="16"/><text x="12.5797%" y="159.50"></text></g><g><title>_raw_spin_lock (5 samples, 0.01%)</title><rect x="12.3709%" y="149" width="0.0129%" height="15" fill="rgb(213,28,5)" fg:x="4804" fg:w="5"/><text x="12.6209%" y="159.50"></text></g><g><title>futex_q_lock (4 samples, 0.01%)</title><rect x="12.3915%" y="149" width="0.0103%" height="15" fill="rgb(215,77,49)" fg:x="4812" fg:w="4"/><text x="12.6415%" y="159.50"></text></g><g><title>futex_q_unlock (7 samples, 0.02%)</title><rect x="12.4018%" y="149" width="0.0180%" height="15" fill="rgb(248,100,22)" fg:x="4816" fg:w="7"/><text x="12.6518%" y="159.50"></text></g><g><title>futex_wait_setup (41 samples, 0.11%)</title><rect x="12.3168%" y="165" width="0.1056%" height="15" fill="rgb(208,67,9)" fg:x="4783" fg:w="41"/><text x="12.5668%" y="175.50"></text></g><g><title>futex_wait (230 samples, 0.59%)</title><rect x="11.8353%" y="181" width="0.5923%" height="15" fill="rgb(219,133,21)" fg:x="4596" fg:w="230"/><text x="12.0853%" y="191.50"></text></g><g><title>do_futex (236 samples, 0.61%)</title><rect x="11.8224%" y="197" width="0.6077%" height="15" fill="rgb(246,46,29)" fg:x="4591" fg:w="236"/><text x="12.0724%" y="207.50"></text></g><g><title>__x64_sys_futex (247 samples, 0.64%)</title><rect x="11.7967%" y="213" width="0.6361%" height="15" fill="rgb(246,185,52)" fg:x="4581" fg:w="247"/><text x="12.0467%" y="223.50"></text></g><g><title>__rseq_handle_notify_resume (7 samples, 0.02%)</title><rect x="12.4817%" y="165" width="0.0180%" height="15" fill="rgb(252,136,11)" fg:x="4847" fg:w="7"/><text x="12.7317%" y="175.50"></text></g><g><title>exit_to_user_mode_loop (21 samples, 0.05%)</title><rect x="12.4559%" y="181" width="0.0541%" height="15" fill="rgb(219,138,53)" fg:x="4837" fg:w="21"/><text x="12.7059%" y="191.50"></text></g><g><title>exit_to_user_mode_prepare (27 samples, 0.07%)</title><rect x="12.4456%" y="197" width="0.0695%" height="15" fill="rgb(211,51,23)" fg:x="4833" fg:w="27"/><text x="12.6956%" y="207.50"></text></g><g><title>do_syscall_64 (283 samples, 0.73%)</title><rect x="11.7941%" y="229" width="0.7288%" height="15" fill="rgb(247,221,28)" fg:x="4580" fg:w="283"/><text x="12.0441%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (31 samples, 0.08%)</title><rect x="12.4430%" y="213" width="0.0798%" height="15" fill="rgb(251,222,45)" fg:x="4832" fg:w="31"/><text x="12.6930%" y="223.50"></text></g><g><title>[libc.so.6] (785 samples, 2.02%)</title><rect x="10.5065%" y="277" width="2.0215%" height="15" fill="rgb(217,162,53)" fg:x="4080" fg:w="785"/><text x="10.7565%" y="287.50">[..</text></g><g><title>__lll_lock_wait_private (346 samples, 0.89%)</title><rect x="11.6370%" y="261" width="0.8910%" height="15" fill="rgb(229,93,14)" fg:x="4519" fg:w="346"/><text x="11.8870%" y="271.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (288 samples, 0.74%)</title><rect x="11.7864%" y="245" width="0.7416%" height="15" fill="rgb(209,67,49)" fg:x="4577" fg:w="288"/><text x="12.0364%" y="255.50"></text></g><g><title>__entry_text_start (13 samples, 0.03%)</title><rect x="12.5383%" y="261" width="0.0335%" height="15" fill="rgb(213,87,29)" fg:x="4869" fg:w="13"/><text x="12.7883%" y="271.50"></text></g><g><title>futex_hash (7 samples, 0.02%)</title><rect x="12.6104%" y="197" width="0.0180%" height="15" fill="rgb(205,151,52)" fg:x="4897" fg:w="7"/><text x="12.8604%" y="207.50"></text></g><g><title>_raw_spin_lock (25 samples, 0.06%)</title><rect x="12.6902%" y="181" width="0.0644%" height="15" fill="rgb(253,215,39)" fg:x="4928" fg:w="25"/><text x="12.9402%" y="191.50"></text></g><g><title>native_queued_spin_lock_slowpath (25 samples, 0.06%)</title><rect x="12.6902%" y="165" width="0.0644%" height="15" fill="rgb(221,220,41)" fg:x="4928" fg:w="25"/><text x="12.9402%" y="175.50"></text></g><g><title>do_futex (66 samples, 0.17%)</title><rect x="12.5975%" y="213" width="0.1700%" height="15" fill="rgb(218,133,21)" fg:x="4892" fg:w="66"/><text x="12.8475%" y="223.50"></text></g><g><title>futex_wake (54 samples, 0.14%)</title><rect x="12.6284%" y="197" width="0.1391%" height="15" fill="rgb(221,193,43)" fg:x="4904" fg:w="54"/><text x="12.8784%" y="207.50"></text></g><g><title>__x64_sys_futex (72 samples, 0.19%)</title><rect x="12.5872%" y="229" width="0.1854%" height="15" fill="rgb(240,128,52)" fg:x="4888" fg:w="72"/><text x="12.8372%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (10 samples, 0.03%)</title><rect x="12.7829%" y="213" width="0.0258%" height="15" fill="rgb(253,114,12)" fg:x="4964" fg:w="10"/><text x="13.0329%" y="223.50"></text></g><g><title>do_syscall_64 (90 samples, 0.23%)</title><rect x="12.5847%" y="245" width="0.2318%" height="15" fill="rgb(215,223,47)" fg:x="4887" fg:w="90"/><text x="12.8347%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (16 samples, 0.04%)</title><rect x="12.7752%" y="229" width="0.0412%" height="15" fill="rgb(248,225,23)" fg:x="4961" fg:w="16"/><text x="13.0252%" y="239.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (98 samples, 0.25%)</title><rect x="12.5744%" y="261" width="0.2524%" height="15" fill="rgb(250,108,0)" fg:x="4883" fg:w="98"/><text x="12.8244%" y="271.50"></text></g><g><title>alloc::alloc::dealloc (965 samples, 2.48%)</title><rect x="10.3494%" y="309" width="2.4850%" height="15" fill="rgb(228,208,7)" fg:x="4019" fg:w="965"/><text x="10.5994%" y="319.50">al..</text></g><g><title>cfree (956 samples, 2.46%)</title><rect x="10.3726%" y="293" width="2.4618%" height="15" fill="rgb(244,45,10)" fg:x="4028" fg:w="956"/><text x="10.6226%" y="303.50">cf..</text></g><g><title>__lll_lock_wake_private (119 samples, 0.31%)</title><rect x="12.5280%" y="277" width="0.3064%" height="15" fill="rgb(207,125,25)" fg:x="4865" fg:w="119"/><text x="12.7780%" y="287.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (970 samples, 2.50%)</title><rect x="10.3494%" y="325" width="2.4979%" height="15" fill="rgb(210,195,18)" fg:x="4019" fg:w="970"/><text x="10.5994%" y="335.50">&lt;a..</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (5 samples, 0.01%)</title><rect x="12.8344%" y="309" width="0.0129%" height="15" fill="rgb(249,80,12)" fg:x="4984" fg:w="5"/><text x="13.0844%" y="319.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (986 samples, 2.54%)</title><rect x="10.3288%" y="469" width="2.5391%" height="15" fill="rgb(221,65,9)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="479.50">co..</text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (986 samples, 2.54%)</title><rect x="10.3288%" y="453" width="2.5391%" height="15" fill="rgb(235,49,36)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="463.50">&lt;a..</text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (986 samples, 2.54%)</title><rect x="10.3288%" y="437" width="2.5391%" height="15" fill="rgb(225,32,20)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="447.50">ar..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (986 samples, 2.54%)</title><rect x="10.3288%" y="421" width="2.5391%" height="15" fill="rgb(215,141,46)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="431.50">ar..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (986 samples, 2.54%)</title><rect x="10.3288%" y="405" width="2.5391%" height="15" fill="rgb(250,160,47)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="415.50">ar..</text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (984 samples, 2.53%)</title><rect x="10.3340%" y="389" width="2.5339%" height="15" fill="rgb(216,222,40)" fg:x="4013" fg:w="984"/><text x="10.5840%" y="399.50">co..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (981 samples, 2.53%)</title><rect x="10.3417%" y="373" width="2.5262%" height="15" fill="rgb(234,217,39)" fg:x="4016" fg:w="981"/><text x="10.5917%" y="383.50">co..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (981 samples, 2.53%)</title><rect x="10.3417%" y="357" width="2.5262%" height="15" fill="rgb(207,178,40)" fg:x="4016" fg:w="981"/><text x="10.5917%" y="367.50">co..</text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (981 samples, 2.53%)</title><rect x="10.3417%" y="341" width="2.5262%" height="15" fill="rgb(221,136,13)" fg:x="4016" fg:w="981"/><text x="10.5917%" y="351.50">&lt;a..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::current_memory (8 samples, 0.02%)</title><rect x="12.8473%" y="325" width="0.0206%" height="15" fill="rgb(249,199,10)" fg:x="4989" fg:w="8"/><text x="13.0973%" y="335.50"></text></g><g><title>core::alloc::layout::Layout::array (6 samples, 0.02%)</title><rect x="12.8525%" y="309" width="0.0155%" height="15" fill="rgb(249,222,13)" fg:x="4991" fg:w="6"/><text x="13.1025%" y="319.50"></text></g><g><title>core::alloc::layout::Layout::array::inner (6 samples, 0.02%)</title><rect x="12.8525%" y="293" width="0.0155%" height="15" fill="rgb(244,185,38)" fg:x="4991" fg:w="6"/><text x="13.1025%" y="303.50"></text></g><g><title>std::sync::poison::Flag::done (10 samples, 0.03%)</title><rect x="12.8679%" y="437" width="0.0258%" height="15" fill="rgb(236,202,9)" fg:x="4997" fg:w="10"/><text x="13.1179%" y="447.50"></text></g><g><title>std::thread::panicking (10 samples, 0.03%)</title><rect x="12.8679%" y="421" width="0.0258%" height="15" fill="rgb(250,229,37)" fg:x="4997" fg:w="10"/><text x="13.1179%" y="431.50"></text></g><g><title>std::panicking::panicking (10 samples, 0.03%)</title><rect x="12.8679%" y="405" width="0.0258%" height="15" fill="rgb(206,174,23)" fg:x="4997" fg:w="10"/><text x="13.1179%" y="415.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (10 samples, 0.03%)</title><rect x="12.8679%" y="389" width="0.0258%" height="15" fill="rgb(211,33,43)" fg:x="4997" fg:w="10"/><text x="13.1179%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (9 samples, 0.02%)</title><rect x="12.8705%" y="373" width="0.0232%" height="15" fill="rgb(245,58,50)" fg:x="4998" fg:w="9"/><text x="13.1205%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (9 samples, 0.02%)</title><rect x="12.8705%" y="357" width="0.0232%" height="15" fill="rgb(244,68,36)" fg:x="4998" fg:w="9"/><text x="13.1205%" y="367.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (78 samples, 0.20%)</title><rect x="12.8679%" y="453" width="0.2009%" height="15" fill="rgb(232,229,15)" fg:x="4997" fg:w="78"/><text x="13.1179%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (68 samples, 0.18%)</title><rect x="12.8937%" y="437" width="0.1751%" height="15" fill="rgb(254,30,23)" fg:x="5007" fg:w="68"/><text x="13.1437%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (66 samples, 0.17%)</title><rect x="12.8988%" y="421" width="0.1700%" height="15" fill="rgb(235,160,14)" fg:x="5009" fg:w="66"/><text x="13.1488%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_swap (66 samples, 0.17%)</title><rect x="12.8988%" y="405" width="0.1700%" height="15" fill="rgb(212,155,44)" fg:x="5009" fg:w="66"/><text x="13.1488%" y="415.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="13.0688%" y="453" width="0.0129%" height="15" fill="rgb(226,2,50)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="463.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="13.0688%" y="437" width="0.0129%" height="15" fill="rgb(234,177,6)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="447.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="13.0688%" y="421" width="0.0129%" height="15" fill="rgb(217,24,9)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="431.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="13.0688%" y="405" width="0.0129%" height="15" fill="rgb(220,13,46)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="415.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="13.0688%" y="389" width="0.0129%" height="15" fill="rgb(239,221,27)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="399.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="13.0688%" y="373" width="0.0129%" height="15" fill="rgb(222,198,25)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="383.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="13.0688%" y="357" width="0.0129%" height="15" fill="rgb(211,99,13)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="367.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="13.0688%" y="341" width="0.0129%" height="15" fill="rgb(232,111,31)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="351.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="13.0688%" y="325" width="0.0129%" height="15" fill="rgb(245,82,37)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="335.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="13.0688%" y="309" width="0.0129%" height="15" fill="rgb(227,149,46)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="319.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="13.0688%" y="293" width="0.0129%" height="15" fill="rgb(218,36,50)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="303.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (88 samples, 0.23%)</title><rect x="12.8679%" y="469" width="0.2266%" height="15" fill="rgb(226,80,48)" fg:x="4997" fg:w="88"/><text x="13.1179%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (5 samples, 0.01%)</title><rect x="13.0817%" y="453" width="0.0129%" height="15" fill="rgb(238,224,15)" fg:x="5080" fg:w="5"/><text x="13.3317%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;std::collections::hash::map::HashMap&lt;core::num::nonzero::NonZeroU32,alloc::sync::Weak&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt;&gt;&gt; (85 samples, 0.22%)</title><rect x="13.0945%" y="469" width="0.2189%" height="15" fill="rgb(241,136,10)" fg:x="5085" fg:w="85"/><text x="13.3445%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (85 samples, 0.22%)</title><rect x="13.0945%" y="453" width="0.2189%" height="15" fill="rgb(208,32,45)" fg:x="5085" fg:w="85"/><text x="13.3445%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (85 samples, 0.22%)</title><rect x="13.0945%" y="437" width="0.2189%" height="15" fill="rgb(207,135,9)" fg:x="5085" fg:w="85"/><text x="13.3445%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (76 samples, 0.20%)</title><rect x="13.1177%" y="421" width="0.1957%" height="15" fill="rgb(206,86,44)" fg:x="5094" fg:w="76"/><text x="13.3677%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (76 samples, 0.20%)</title><rect x="13.1177%" y="405" width="0.1957%" height="15" fill="rgb(245,177,15)" fg:x="5094" fg:w="76"/><text x="13.3677%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (66 samples, 0.17%)</title><rect x="13.3134%" y="469" width="0.1700%" height="15" fill="rgb(206,64,50)" fg:x="5170" fg:w="66"/><text x="13.5634%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (66 samples, 0.17%)</title><rect x="13.3134%" y="453" width="0.1700%" height="15" fill="rgb(234,36,40)" fg:x="5170" fg:w="66"/><text x="13.5634%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (66 samples, 0.17%)</title><rect x="13.3134%" y="437" width="0.1700%" height="15" fill="rgb(213,64,8)" fg:x="5170" fg:w="66"/><text x="13.5634%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (57 samples, 0.15%)</title><rect x="13.3366%" y="421" width="0.1468%" height="15" fill="rgb(210,75,36)" fg:x="5179" fg:w="57"/><text x="13.5866%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (57 samples, 0.15%)</title><rect x="13.3366%" y="405" width="0.1468%" height="15" fill="rgb(229,88,21)" fg:x="5179" fg:w="57"/><text x="13.5866%" y="415.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (4 samples, 0.01%)</title><rect x="13.5529%" y="325" width="0.0103%" height="15" fill="rgb(252,204,47)" fg:x="5263" fg:w="4"/><text x="13.8029%" y="335.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::c_rounds (20 samples, 0.05%)</title><rect x="13.5220%" y="341" width="0.0515%" height="15" fill="rgb(208,77,27)" fg:x="5251" fg:w="20"/><text x="13.7720%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (4 samples, 0.01%)</title><rect x="13.5632%" y="325" width="0.0103%" height="15" fill="rgb(221,76,26)" fg:x="5267" fg:w="4"/><text x="13.8132%" y="335.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (7 samples, 0.02%)</title><rect x="13.6018%" y="325" width="0.0180%" height="15" fill="rgb(225,139,18)" fg:x="5282" fg:w="7"/><text x="13.8518%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::finish (62 samples, 0.16%)</title><rect x="13.4963%" y="389" width="0.1597%" height="15" fill="rgb(230,137,11)" fg:x="5241" fg:w="62"/><text x="13.7463%" y="399.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::finish (62 samples, 0.16%)</title><rect x="13.4963%" y="373" width="0.1597%" height="15" fill="rgb(212,28,1)" fg:x="5241" fg:w="62"/><text x="13.7463%" y="383.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::finish (62 samples, 0.16%)</title><rect x="13.4963%" y="357" width="0.1597%" height="15" fill="rgb(248,164,17)" fg:x="5241" fg:w="62"/><text x="13.7463%" y="367.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::d_rounds (32 samples, 0.08%)</title><rect x="13.5735%" y="341" width="0.0824%" height="15" fill="rgb(222,171,42)" fg:x="5271" fg:w="32"/><text x="13.8235%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (14 samples, 0.04%)</title><rect x="13.6199%" y="325" width="0.0361%" height="15" fill="rgb(243,84,45)" fg:x="5289" fg:w="14"/><text x="13.8699%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::RandomState as core::hash::BuildHasher&gt;::build_hasher (17 samples, 0.04%)</title><rect x="13.6559%" y="389" width="0.0438%" height="15" fill="rgb(252,49,23)" fg:x="5303" fg:w="17"/><text x="13.9059%" y="399.50"></text></g><g><title>core::hash::sip::SipHasher13::new_with_keys (8 samples, 0.02%)</title><rect x="13.6791%" y="373" width="0.0206%" height="15" fill="rgb(215,19,7)" fg:x="5312" fg:w="8"/><text x="13.9291%" y="383.50"></text></g><g><title>core::hash::sip::Hasher&lt;S&gt;::new_with_keys (8 samples, 0.02%)</title><rect x="13.6791%" y="357" width="0.0206%" height="15" fill="rgb(238,81,41)" fg:x="5312" fg:w="8"/><text x="13.9291%" y="367.50"></text></g><g><title>core::hash::sip::Hasher&lt;S&gt;::reset (8 samples, 0.02%)</title><rect x="13.6791%" y="341" width="0.0206%" height="15" fill="rgb(210,199,37)" fg:x="5312" fg:w="8"/><text x="13.9291%" y="351.50"></text></g><g><title>hashbrown::map::make_hash (104 samples, 0.27%)</title><rect x="13.4911%" y="421" width="0.2678%" height="15" fill="rgb(244,192,49)" fg:x="5239" fg:w="104"/><text x="13.7411%" y="431.50"></text></g><g><title>core::hash::BuildHasher::hash_one (104 samples, 0.27%)</title><rect x="13.4911%" y="405" width="0.2678%" height="15" fill="rgb(226,211,11)" fg:x="5239" fg:w="104"/><text x="13.7411%" y="415.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (23 samples, 0.06%)</title><rect x="13.6997%" y="389" width="0.0592%" height="15" fill="rgb(236,162,54)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="399.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (23 samples, 0.06%)</title><rect x="13.6997%" y="373" width="0.0592%" height="15" fill="rgb(220,229,9)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="383.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for u32&gt;::hash (23 samples, 0.06%)</title><rect x="13.6997%" y="357" width="0.0592%" height="15" fill="rgb(250,87,22)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="367.50"></text></g><g><title>core::hash::Hasher::write_u32 (23 samples, 0.06%)</title><rect x="13.6997%" y="341" width="0.0592%" height="15" fill="rgb(239,43,17)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="351.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::write (23 samples, 0.06%)</title><rect x="13.6997%" y="325" width="0.0592%" height="15" fill="rgb(231,177,25)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="335.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::write (23 samples, 0.06%)</title><rect x="13.6997%" y="309" width="0.0592%" height="15" fill="rgb(219,179,1)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="319.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::write (23 samples, 0.06%)</title><rect x="13.6997%" y="293" width="0.0592%" height="15" fill="rgb(238,219,53)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="303.50"></text></g><g><title>core::hash::sip::u8to64_le (15 samples, 0.04%)</title><rect x="13.7203%" y="277" width="0.0386%" height="15" fill="rgb(232,167,36)" fg:x="5328" fg:w="15"/><text x="13.9703%" y="287.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find::_{{closure}} (5 samples, 0.01%)</title><rect x="13.7847%" y="373" width="0.0129%" height="15" fill="rgb(244,19,51)" fg:x="5353" fg:w="5"/><text x="14.0347%" y="383.50"></text></g><g><title>hashbrown::raw::h2 (8 samples, 0.02%)</title><rect x="13.7975%" y="373" width="0.0206%" height="15" fill="rgb(224,6,22)" fg:x="5358" fg:w="8"/><text x="14.0475%" y="383.50"></text></g><g><title>hashbrown::raw::sse2::Group::load (29 samples, 0.07%)</title><rect x="13.8181%" y="373" width="0.0747%" height="15" fill="rgb(224,145,5)" fg:x="5366" fg:w="29"/><text x="14.0681%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_loadu_si128 (29 samples, 0.07%)</title><rect x="13.8181%" y="357" width="0.0747%" height="15" fill="rgb(234,130,49)" fg:x="5366" fg:w="29"/><text x="14.0681%" y="367.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (29 samples, 0.07%)</title><rect x="13.8181%" y="341" width="0.0747%" height="15" fill="rgb(254,6,2)" fg:x="5366" fg:w="29"/><text x="14.0681%" y="351.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (163 samples, 0.42%)</title><rect x="13.4911%" y="437" width="0.4197%" height="15" fill="rgb(208,96,46)" fg:x="5239" fg:w="163"/><text x="13.7411%" y="447.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::get (59 samples, 0.15%)</title><rect x="13.7589%" y="421" width="0.1519%" height="15" fill="rgb(239,3,39)" fg:x="5343" fg:w="59"/><text x="14.0089%" y="431.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find (59 samples, 0.15%)</title><rect x="13.7589%" y="405" width="0.1519%" height="15" fill="rgb(233,210,1)" fg:x="5343" fg:w="59"/><text x="14.0089%" y="415.50"></text></g><g><title>hashbrown::raw::RawTableInner&lt;A&gt;::find_inner (59 samples, 0.15%)</title><rect x="13.7589%" y="389" width="0.1519%" height="15" fill="rgb(244,137,37)" fg:x="5343" fg:w="59"/><text x="14.0089%" y="399.50"></text></g><g><title>hashbrown::raw::sse2::Group::match_byte (7 samples, 0.02%)</title><rect x="13.8928%" y="373" width="0.0180%" height="15" fill="rgb(240,136,2)" fg:x="5395" fg:w="7"/><text x="14.1428%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_movemask_epi8 (7 samples, 0.02%)</title><rect x="13.8928%" y="357" width="0.0180%" height="15" fill="rgb(239,18,37)" fg:x="5395" fg:w="7"/><text x="14.1428%" y="367.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (164 samples, 0.42%)</title><rect x="13.4911%" y="469" width="0.4223%" height="15" fill="rgb(218,185,22)" fg:x="5239" fg:w="164"/><text x="13.7411%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (164 samples, 0.42%)</title><rect x="13.4911%" y="453" width="0.4223%" height="15" fill="rgb(225,218,4)" fg:x="5239" fg:w="164"/><text x="13.7411%" y="463.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="13.9315%" y="437" width="0.0129%" height="15" fill="rgb(230,182,32)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="447.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="13.9315%" y="421" width="0.0129%" height="15" fill="rgb(242,56,43)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="431.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="13.9315%" y="405" width="0.0129%" height="15" fill="rgb(233,99,24)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="415.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="13.9315%" y="389" width="0.0129%" height="15" fill="rgb(234,209,42)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="399.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="13.9315%" y="373" width="0.0129%" height="15" fill="rgb(227,7,12)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="383.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="13.9315%" y="357" width="0.0129%" height="15" fill="rgb(245,203,43)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="367.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="13.9315%" y="341" width="0.0129%" height="15" fill="rgb(238,205,33)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="351.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="13.9315%" y="325" width="0.0129%" height="15" fill="rgb(231,56,7)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="335.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="13.9315%" y="309" width="0.0129%" height="15" fill="rgb(244,186,29)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="319.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="13.9315%" y="293" width="0.0129%" height="15" fill="rgb(234,111,31)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="303.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="13.9315%" y="277" width="0.0129%" height="15" fill="rgb(241,149,10)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="287.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (42 samples, 0.11%)</title><rect x="13.9134%" y="469" width="0.1082%" height="15" fill="rgb(249,206,44)" fg:x="5403" fg:w="42"/><text x="14.1634%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (38 samples, 0.10%)</title><rect x="13.9237%" y="453" width="0.0979%" height="15" fill="rgb(251,153,30)" fg:x="5407" fg:w="38"/><text x="14.1737%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (30 samples, 0.08%)</title><rect x="13.9443%" y="437" width="0.0773%" height="15" fill="rgb(239,152,38)" fg:x="5415" fg:w="30"/><text x="14.1943%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (30 samples, 0.08%)</title><rect x="13.9443%" y="421" width="0.0773%" height="15" fill="rgb(249,139,47)" fg:x="5415" fg:w="30"/><text x="14.1943%" y="431.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="14.0654%" y="437" width="0.0129%" height="15" fill="rgb(244,64,35)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="447.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="14.0654%" y="421" width="0.0129%" height="15" fill="rgb(216,46,15)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="431.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="14.0654%" y="405" width="0.0129%" height="15" fill="rgb(250,74,19)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="415.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="14.0654%" y="389" width="0.0129%" height="15" fill="rgb(249,42,33)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="399.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="14.0654%" y="373" width="0.0129%" height="15" fill="rgb(242,149,17)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="383.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="14.0654%" y="357" width="0.0129%" height="15" fill="rgb(244,29,21)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="367.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="14.0654%" y="341" width="0.0129%" height="15" fill="rgb(220,130,37)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="351.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="14.0654%" y="325" width="0.0129%" height="15" fill="rgb(211,67,2)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="335.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="14.0654%" y="309" width="0.0129%" height="15" fill="rgb(235,68,52)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="319.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="14.0654%" y="293" width="0.0129%" height="15" fill="rgb(246,142,3)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="303.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="14.0654%" y="277" width="0.0129%" height="15" fill="rgb(241,25,7)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="287.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (128 samples, 0.33%)</title><rect x="14.0782%" y="437" width="0.3296%" height="15" fill="rgb(242,119,39)" fg:x="5467" fg:w="128"/><text x="14.3282%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (128 samples, 0.33%)</title><rect x="14.0782%" y="421" width="0.3296%" height="15" fill="rgb(241,98,45)" fg:x="5467" fg:w="128"/><text x="14.3282%" y="431.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (162 samples, 0.42%)</title><rect x="14.0216%" y="469" width="0.4172%" height="15" fill="rgb(254,28,30)" fg:x="5445" fg:w="162"/><text x="14.2716%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (162 samples, 0.42%)</title><rect x="14.0216%" y="453" width="0.4172%" height="15" fill="rgb(241,142,54)" fg:x="5445" fg:w="162"/><text x="14.2716%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::is_read_lockable (12 samples, 0.03%)</title><rect x="14.4078%" y="437" width="0.0309%" height="15" fill="rgb(222,85,15)" fg:x="5595" fg:w="12"/><text x="14.6578%" y="447.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (5 samples, 0.01%)</title><rect x="14.4413%" y="453" width="0.0129%" height="15" fill="rgb(210,85,47)" fg:x="5608" fg:w="5"/><text x="14.6913%" y="463.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::check (13 samples, 0.03%)</title><rect x="14.4388%" y="469" width="0.0335%" height="15" fill="rgb(224,206,25)" fg:x="5607" fg:w="13"/><text x="14.6888%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicU64::load (7 samples, 0.02%)</title><rect x="14.4542%" y="453" width="0.0180%" height="15" fill="rgb(243,201,19)" fg:x="5613" fg:w="7"/><text x="14.7042%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_load (7 samples, 0.02%)</title><rect x="14.4542%" y="437" width="0.0180%" height="15" fill="rgb(236,59,4)" fg:x="5613" fg:w="7"/><text x="14.7042%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::push (20 samples, 0.05%)</title><rect x="14.5933%" y="453" width="0.0515%" height="15" fill="rgb(254,179,45)" fg:x="5667" fg:w="20"/><text x="14.8433%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push (20 samples, 0.05%)</title><rect x="14.5933%" y="437" width="0.0515%" height="15" fill="rgb(226,14,10)" fg:x="5667" fg:w="20"/><text x="14.8433%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::try_push (20 samples, 0.05%)</title><rect x="14.5933%" y="421" width="0.0515%" height="15" fill="rgb(244,27,41)" fg:x="5667" fg:w="20"/><text x="14.8433%" y="431.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push_unchecked (13 samples, 0.03%)</title><rect x="14.6113%" y="405" width="0.0335%" height="15" fill="rgb(235,35,32)" fg:x="5674" fg:w="13"/><text x="14.8613%" y="415.50"></text></g><g><title>core::ptr::write (12 samples, 0.03%)</title><rect x="14.6139%" y="389" width="0.0309%" height="15" fill="rgb(218,68,31)" fg:x="5675" fg:w="12"/><text x="14.8639%" y="399.50"></text></g><g><title>core::array::equality::_&lt;impl core::cmp::PartialEq&lt;[B: N]&gt; for [A: N]&gt;::ne (5 samples, 0.01%)</title><rect x="14.6448%" y="453" width="0.0129%" height="15" fill="rgb(207,120,37)" fg:x="5687" fg:w="5"/><text x="14.8948%" y="463.50"></text></g><g><title>&lt;T as core::array::equality::SpecArrayEq&lt;U,_&gt;&gt;::spec_ne (5 samples, 0.01%)</title><rect x="14.6448%" y="437" width="0.0129%" height="15" fill="rgb(227,98,0)" fg:x="5687" fg:w="5"/><text x="14.8948%" y="447.50"></text></g><g><title>&lt;T as core::array::equality::SpecArrayEq&lt;U,_&gt;&gt;::spec_eq (5 samples, 0.01%)</title><rect x="14.6448%" y="421" width="0.0129%" height="15" fill="rgb(207,7,3)" fg:x="5687" fg:w="5"/><text x="14.8948%" y="431.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init_read (7 samples, 0.02%)</title><rect x="14.6628%" y="453" width="0.0180%" height="15" fill="rgb(206,98,19)" fg:x="5694" fg:w="7"/><text x="14.9128%" y="463.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::read (7 samples, 0.02%)</title><rect x="14.6628%" y="437" width="0.0180%" height="15" fill="rgb(217,5,26)" fg:x="5694" fg:w="7"/><text x="14.9128%" y="447.50"></text></g><g><title>core::ptr::read (7 samples, 0.02%)</title><rect x="14.6628%" y="421" width="0.0180%" height="15" fill="rgb(235,190,38)" fg:x="5694" fg:w="7"/><text x="14.9128%" y="431.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init (7 samples, 0.02%)</title><rect x="14.6628%" y="405" width="0.0180%" height="15" fill="rgb(247,86,24)" fg:x="5694" fg:w="7"/><text x="14.9128%" y="415.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_shl (6 samples, 0.02%)</title><rect x="14.6885%" y="453" width="0.0155%" height="15" fill="rgb(205,101,16)" fg:x="5704" fg:w="6"/><text x="14.9385%" y="463.50"></text></g><g><title>core::num::&lt;impl u64&gt;::unchecked_shl (6 samples, 0.02%)</title><rect x="14.6885%" y="437" width="0.0155%" height="15" fill="rgb(246,168,33)" fg:x="5704" fg:w="6"/><text x="14.9385%" y="447.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (98 samples, 0.25%)</title><rect x="14.4722%" y="469" width="0.2524%" height="15" fill="rgb(231,114,1)" fg:x="5620" fg:w="98"/><text x="14.7222%" y="479.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::drop_in_place (5 samples, 0.01%)</title><rect x="14.7117%" y="453" width="0.0129%" height="15" fill="rgb(207,184,53)" fg:x="5713" fg:w="5"/><text x="14.9617%" y="463.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (26 samples, 0.07%)</title><rect x="14.7246%" y="453" width="0.0670%" height="15" fill="rgb(224,95,51)" fg:x="5718" fg:w="26"/><text x="14.9746%" y="463.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (26 samples, 0.07%)</title><rect x="14.7246%" y="437" width="0.0670%" height="15" fill="rgb(212,188,45)" fg:x="5718" fg:w="26"/><text x="14.9746%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (26 samples, 0.07%)</title><rect x="14.7246%" y="421" width="0.0670%" height="15" fill="rgb(223,154,38)" fg:x="5718" fg:w="26"/><text x="14.9746%" y="431.50"></text></g><g><title>zssp::zeta::from_nonce (32 samples, 0.08%)</title><rect x="14.7246%" y="469" width="0.0824%" height="15" fill="rgb(251,22,52)" fg:x="5718" fg:w="32"/><text x="14.9746%" y="479.50"></text></g><g><title>core::num::&lt;impl u64&gt;::from_be_bytes (6 samples, 0.02%)</title><rect x="14.7915%" y="453" width="0.0155%" height="15" fill="rgb(229,209,22)" fg:x="5744" fg:w="6"/><text x="15.0415%" y="463.50"></text></g><g><title>core::num::&lt;impl u64&gt;::from_be (6 samples, 0.02%)</title><rect x="14.7915%" y="437" width="0.0155%" height="15" fill="rgb(234,138,34)" fg:x="5744" fg:w="6"/><text x="15.0415%" y="447.50"></text></g><g><title>core::num::&lt;impl u64&gt;::swap_bytes (6 samples, 0.02%)</title><rect x="14.7915%" y="421" width="0.0155%" height="15" fill="rgb(212,95,11)" fg:x="5744" fg:w="6"/><text x="15.0415%" y="431.50"></text></g><g><title>&lt;alloc::vec::Vec&lt;T,A&gt; as core::convert::AsMut&lt;[T]&gt;&gt;::as_mut (4 samples, 0.01%)</title><rect x="14.8405%" y="453" width="0.0103%" height="15" fill="rgb(240,179,47)" fg:x="5763" fg:w="4"/><text x="15.0905%" y="463.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (69 samples, 0.18%)</title><rect x="14.8585%" y="453" width="0.1777%" height="15" fill="rgb(240,163,11)" fg:x="5770" fg:w="69"/><text x="15.1085%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (69 samples, 0.18%)</title><rect x="14.8585%" y="437" width="0.1777%" height="15" fill="rgb(236,37,12)" fg:x="5770" fg:w="69"/><text x="15.1085%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (68 samples, 0.18%)</title><rect x="14.8611%" y="421" width="0.1751%" height="15" fill="rgb(232,164,16)" fg:x="5771" fg:w="68"/><text x="15.1111%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (68 samples, 0.18%)</title><rect x="14.8611%" y="405" width="0.1751%" height="15" fill="rgb(244,205,15)" fg:x="5771" fg:w="68"/><text x="15.1111%" y="415.50"></text></g><g><title>CRYPTO_gcm128_decrypt (249 samples, 0.64%)</title><rect x="15.4508%" y="357" width="0.6412%" height="15" fill="rgb(223,117,47)" fg:x="6000" fg:w="249"/><text x="15.7008%" y="367.50"></text></g><g><title>[libcrypto.so.3] (120 samples, 0.31%)</title><rect x="15.7830%" y="341" width="0.3090%" height="15" fill="rgb(244,107,35)" fg:x="6129" fg:w="120"/><text x="16.0330%" y="351.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="16.0791%" y="325" width="0.0129%" height="15" fill="rgb(205,140,8)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="16.0791%" y="309" width="0.0129%" height="15" fill="rgb(228,84,46)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="16.0791%" y="293" width="0.0129%" height="15" fill="rgb(254,188,9)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="16.0791%" y="277" width="0.0129%" height="15" fill="rgb(206,112,54)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="16.0791%" y="261" width="0.0129%" height="15" fill="rgb(216,84,49)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="16.0791%" y="245" width="0.0129%" height="15" fill="rgb(214,194,35)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="16.0791%" y="229" width="0.0129%" height="15" fill="rgb(249,28,3)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="16.0791%" y="213" width="0.0129%" height="15" fill="rgb(222,56,52)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="16.0791%" y="197" width="0.0129%" height="15" fill="rgb(245,217,50)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="16.0791%" y="181" width="0.0129%" height="15" fill="rgb(213,201,24)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="191.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="16.0791%" y="165" width="0.0129%" height="15" fill="rgb(248,116,28)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="175.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (478 samples, 1.23%)</title><rect x="16.0920%" y="357" width="1.2309%" height="15" fill="rgb(219,72,43)" fg:x="6249" fg:w="478"/><text x="16.3420%" y="367.50"></text></g><g><title>[libcrypto.so.3] (360 samples, 0.93%)</title><rect x="16.3958%" y="341" width="0.9270%" height="15" fill="rgb(209,138,14)" fg:x="6367" fg:w="360"/><text x="16.6458%" y="351.50"></text></g><g><title>[libcrypto.so.3] (22 samples, 0.06%)</title><rect x="17.2662%" y="325" width="0.0567%" height="15" fill="rgb(222,18,33)" fg:x="6705" fg:w="22"/><text x="17.5162%" y="335.50"></text></g><g><title>CRYPTO_gcm128_setiv (23 samples, 0.06%)</title><rect x="17.3229%" y="357" width="0.0592%" height="15" fill="rgb(213,199,7)" fg:x="6727" fg:w="23"/><text x="17.5729%" y="367.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="17.3306%" y="341" width="0.0515%" height="15" fill="rgb(250,110,10)" fg:x="6730" fg:w="20"/><text x="17.5806%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (4,848 samples, 12.48%)</title><rect x="15.0362%" y="453" width="12.4842%" height="15" fill="rgb(248,123,6)" fg:x="5839" fg:w="4848"/><text x="15.2862%" y="463.50">&lt;zssp::crypto_impl:..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4,846 samples, 12.48%)</title><rect x="15.0413%" y="437" width="12.4791%" height="15" fill="rgb(206,91,31)" fg:x="5841" fg:w="4846"/><text x="15.2913%" y="447.50">zssp::crypto_impl::..</text></g><g><title>EVP_DecryptUpdate (4,846 samples, 12.48%)</title><rect x="15.0413%" y="421" width="12.4791%" height="15" fill="rgb(211,154,13)" fg:x="5841" fg:w="4846"/><text x="15.2913%" y="431.50">EVP_DecryptUpdate</text></g><g><title>[libcrypto.so.3] (4,745 samples, 12.22%)</title><rect x="15.3014%" y="405" width="12.2190%" height="15" fill="rgb(225,148,7)" fg:x="5942" fg:w="4745"/><text x="15.5514%" y="415.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,741 samples, 12.21%)</title><rect x="15.3117%" y="389" width="12.2087%" height="15" fill="rgb(220,160,43)" fg:x="5946" fg:w="4741"/><text x="15.5617%" y="399.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,719 samples, 12.15%)</title><rect x="15.3684%" y="373" width="12.1520%" height="15" fill="rgb(213,52,39)" fg:x="5968" fg:w="4719"/><text x="15.6184%" y="383.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,937 samples, 10.14%)</title><rect x="17.3821%" y="357" width="10.1383%" height="15" fill="rgb(243,137,7)" fg:x="6750" fg:w="3937"/><text x="17.6321%" y="367.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,769 samples, 9.71%)</title><rect x="17.8147%" y="341" width="9.7057%" height="15" fill="rgb(230,79,13)" fg:x="6918" fg:w="3769"/><text x="18.0647%" y="351.50">[libcrypto.so...</text></g><g><title>asm_sysvec_apic_timer_interrupt (6 samples, 0.02%)</title><rect x="27.5050%" y="325" width="0.0155%" height="15" fill="rgb(247,105,23)" fg:x="10681" fg:w="6"/><text x="27.7550%" y="335.50"></text></g><g><title>sysvec_apic_timer_interrupt (6 samples, 0.02%)</title><rect x="27.5050%" y="309" width="0.0155%" height="15" fill="rgb(223,179,41)" fg:x="10681" fg:w="6"/><text x="27.7550%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="27.5075%" y="293" width="0.0129%" height="15" fill="rgb(218,9,34)" fg:x="10682" fg:w="5"/><text x="27.7575%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="27.5075%" y="277" width="0.0129%" height="15" fill="rgb(222,106,8)" fg:x="10682" fg:w="5"/><text x="27.7575%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="27.5075%" y="261" width="0.0129%" height="15" fill="rgb(211,220,0)" fg:x="10682" fg:w="5"/><text x="27.7575%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="27.5075%" y="245" width="0.0129%" height="15" fill="rgb(229,52,16)" fg:x="10682" fg:w="5"/><text x="27.7575%" y="255.50"></text></g><g><title>schedule (4 samples, 0.01%)</title><rect x="27.5101%" y="229" width="0.0103%" height="15" fill="rgb(212,155,18)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="239.50"></text></g><g><title>__schedule (4 samples, 0.01%)</title><rect x="27.5101%" y="213" width="0.0103%" height="15" fill="rgb(242,21,14)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="27.5101%" y="197" width="0.0103%" height="15" fill="rgb(222,19,48)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="27.5101%" y="181" width="0.0103%" height="15" fill="rgb(232,45,27)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="191.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="27.5101%" y="165" width="0.0103%" height="15" fill="rgb(249,103,42)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="175.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec&gt; (13 samples, 0.03%)</title><rect x="27.5281%" y="437" width="0.0335%" height="15" fill="rgb(246,81,33)" fg:x="10690" fg:w="13"/><text x="27.7781%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (13 samples, 0.03%)</title><rect x="27.5281%" y="421" width="0.0335%" height="15" fill="rgb(252,33,42)" fg:x="10690" fg:w="13"/><text x="27.7781%" y="431.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (13 samples, 0.03%)</title><rect x="27.5281%" y="405" width="0.0335%" height="15" fill="rgb(209,212,41)" fg:x="10690" fg:w="13"/><text x="27.7781%" y="415.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (12 samples, 0.03%)</title><rect x="27.5307%" y="389" width="0.0309%" height="15" fill="rgb(207,154,6)" fg:x="10691" fg:w="12"/><text x="27.7807%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (12 samples, 0.03%)</title><rect x="27.5307%" y="373" width="0.0309%" height="15" fill="rgb(223,64,47)" fg:x="10691" fg:w="12"/><text x="27.7807%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_swap (12 samples, 0.03%)</title><rect x="27.5307%" y="357" width="0.0309%" height="15" fill="rgb(211,161,38)" fg:x="10691" fg:w="12"/><text x="27.7807%" y="367.50"></text></g><g><title>[libc.so.6] (6 samples, 0.02%)</title><rect x="27.6363%" y="341" width="0.0155%" height="15" fill="rgb(219,138,40)" fg:x="10732" fg:w="6"/><text x="27.8863%" y="351.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="27.6517%" y="341" width="0.0515%" height="15" fill="rgb(241,228,46)" fg:x="10738" fg:w="20"/><text x="27.9017%" y="351.50"></text></g><g><title>CRYPTO_gcm128_finish (40 samples, 0.10%)</title><rect x="27.6028%" y="357" width="0.1030%" height="15" fill="rgb(223,209,38)" fg:x="10719" fg:w="40"/><text x="27.8528%" y="367.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (59 samples, 0.15%)</title><rect x="27.5616%" y="437" width="0.1519%" height="15" fill="rgb(236,164,45)" fg:x="10703" fg:w="59"/><text x="27.8116%" y="447.50"></text></g><g><title>EVP_DecryptFinal_ex (59 samples, 0.15%)</title><rect x="27.5616%" y="421" width="0.1519%" height="15" fill="rgb(231,15,5)" fg:x="10703" fg:w="59"/><text x="27.8116%" y="431.50"></text></g><g><title>[libcrypto.so.3] (50 samples, 0.13%)</title><rect x="27.5848%" y="405" width="0.1288%" height="15" fill="rgb(252,35,15)" fg:x="10712" fg:w="50"/><text x="27.8348%" y="415.50"></text></g><g><title>[libcrypto.so.3] (50 samples, 0.13%)</title><rect x="27.5848%" y="389" width="0.1288%" height="15" fill="rgb(248,181,18)" fg:x="10712" fg:w="50"/><text x="27.8348%" y="399.50"></text></g><g><title>[libcrypto.so.3] (46 samples, 0.12%)</title><rect x="27.5951%" y="373" width="0.1185%" height="15" fill="rgb(233,39,42)" fg:x="10716" fg:w="46"/><text x="27.8451%" y="383.50"></text></g><g><title>OSSL_PARAM_get_octet_string (5 samples, 0.01%)</title><rect x="27.8088%" y="389" width="0.0129%" height="15" fill="rgb(238,110,33)" fg:x="10799" fg:w="5"/><text x="28.0588%" y="399.50"></text></g><g><title>[libcrypto.so.3] (4 samples, 0.01%)</title><rect x="27.8114%" y="373" width="0.0103%" height="15" fill="rgb(233,195,10)" fg:x="10800" fg:w="4"/><text x="28.0614%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (27 samples, 0.07%)</title><rect x="27.8217%" y="389" width="0.0695%" height="15" fill="rgb(254,105,3)" fg:x="10804" fg:w="27"/><text x="28.0717%" y="399.50"></text></g><g><title>[libc.so.6] (16 samples, 0.04%)</title><rect x="27.8500%" y="373" width="0.0412%" height="15" fill="rgb(221,225,9)" fg:x="10815" fg:w="16"/><text x="28.1000%" y="383.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (145 samples, 0.37%)</title><rect x="27.5204%" y="453" width="0.3734%" height="15" fill="rgb(224,227,45)" fg:x="10687" fg:w="145"/><text x="27.7704%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::set_tag (70 samples, 0.18%)</title><rect x="27.7135%" y="437" width="0.1803%" height="15" fill="rgb(229,198,43)" fg:x="10762" fg:w="70"/><text x="27.9635%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (70 samples, 0.18%)</title><rect x="27.7135%" y="421" width="0.1803%" height="15" fill="rgb(206,209,35)" fg:x="10762" fg:w="70"/><text x="27.9635%" y="431.50"></text></g><g><title>[libcrypto.so.3] (40 samples, 0.10%)</title><rect x="27.7908%" y="405" width="0.1030%" height="15" fill="rgb(245,195,53)" fg:x="10792" fg:w="40"/><text x="28.0408%" y="415.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (18 samples, 0.05%)</title><rect x="27.8964%" y="437" width="0.0464%" height="15" fill="rgb(240,92,26)" fg:x="10833" fg:w="18"/><text x="28.1464%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (18 samples, 0.05%)</title><rect x="27.8964%" y="421" width="0.0464%" height="15" fill="rgb(207,40,23)" fg:x="10833" fg:w="18"/><text x="28.1464%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (17 samples, 0.04%)</title><rect x="27.8990%" y="405" width="0.0438%" height="15" fill="rgb(223,111,35)" fg:x="10834" fg:w="17"/><text x="28.1490%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (17 samples, 0.04%)</title><rect x="27.8990%" y="389" width="0.0438%" height="15" fill="rgb(229,147,28)" fg:x="10834" fg:w="17"/><text x="28.1490%" y="399.50"></text></g><g><title>[libc.so.6] (14 samples, 0.04%)</title><rect x="28.1951%" y="341" width="0.0361%" height="15" fill="rgb(211,29,28)" fg:x="10949" fg:w="14"/><text x="28.4451%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (37 samples, 0.10%)</title><rect x="28.1487%" y="357" width="0.0953%" height="15" fill="rgb(228,72,33)" fg:x="10931" fg:w="37"/><text x="28.3987%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="28.2311%" y="341" width="0.0129%" height="15" fill="rgb(205,214,31)" fg:x="10963" fg:w="5"/><text x="28.4811%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (70 samples, 0.18%)</title><rect x="28.0715%" y="389" width="0.1803%" height="15" fill="rgb(224,111,15)" fg:x="10901" fg:w="70"/><text x="28.3215%" y="399.50"></text></g><g><title>[libcrypto.so.3] (47 samples, 0.12%)</title><rect x="28.1307%" y="373" width="0.1210%" height="15" fill="rgb(253,21,26)" fg:x="10924" fg:w="47"/><text x="28.3807%" y="383.50"></text></g><g><title>[libc.so.6] (22 samples, 0.06%)</title><rect x="28.4063%" y="341" width="0.0567%" height="15" fill="rgb(245,139,43)" fg:x="11031" fg:w="22"/><text x="28.6563%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (50 samples, 0.13%)</title><rect x="28.3470%" y="357" width="0.1288%" height="15" fill="rgb(252,170,7)" fg:x="11008" fg:w="50"/><text x="28.5970%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="28.4629%" y="341" width="0.0129%" height="15" fill="rgb(231,118,14)" fg:x="11053" fg:w="5"/><text x="28.7129%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (92 samples, 0.24%)</title><rect x="28.2517%" y="389" width="0.2369%" height="15" fill="rgb(238,83,0)" fg:x="10971" fg:w="92"/><text x="28.5017%" y="399.50"></text></g><g><title>[libcrypto.so.3] (72 samples, 0.19%)</title><rect x="28.3032%" y="373" width="0.1854%" height="15" fill="rgb(221,39,39)" fg:x="10991" fg:w="72"/><text x="28.5532%" y="383.50"></text></g><g><title>OSSL_PARAM_locate_const (5 samples, 0.01%)</title><rect x="28.4758%" y="357" width="0.0129%" height="15" fill="rgb(222,119,46)" fg:x="11058" fg:w="5"/><text x="28.7258%" y="367.50"></text></g><g><title>EVP_CIPHER_free (13 samples, 0.03%)</title><rect x="28.4887%" y="389" width="0.0335%" height="15" fill="rgb(222,165,49)" fg:x="11063" fg:w="13"/><text x="28.7387%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (46 samples, 0.12%)</title><rect x="28.5221%" y="389" width="0.1185%" height="15" fill="rgb(219,113,52)" fg:x="11076" fg:w="46"/><text x="28.7721%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (292 samples, 0.75%)</title><rect x="27.8938%" y="453" width="0.7519%" height="15" fill="rgb(214,7,15)" fg:x="10832" fg:w="292"/><text x="28.1438%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (273 samples, 0.70%)</title><rect x="27.9427%" y="437" width="0.7030%" height="15" fill="rgb(235,32,4)" fg:x="10851" fg:w="273"/><text x="28.1927%" y="447.50"></text></g><g><title>EVP_CipherInit_ex (272 samples, 0.70%)</title><rect x="27.9453%" y="421" width="0.7004%" height="15" fill="rgb(238,90,54)" fg:x="10852" fg:w="272"/><text x="28.1953%" y="431.50"></text></g><g><title>[libcrypto.so.3] (272 samples, 0.70%)</title><rect x="27.9453%" y="405" width="0.7004%" height="15" fill="rgb(213,208,19)" fg:x="10852" fg:w="272"/><text x="28.1953%" y="415.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (6 samples, 0.02%)</title><rect x="28.6560%" y="437" width="0.0155%" height="15" fill="rgb(233,156,4)" fg:x="11128" fg:w="6"/><text x="28.9060%" y="447.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (4 samples, 0.01%)</title><rect x="28.6612%" y="421" width="0.0103%" height="15" fill="rgb(207,194,5)" fg:x="11130" fg:w="4"/><text x="28.9112%" y="431.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (4 samples, 0.01%)</title><rect x="28.6612%" y="405" width="0.0103%" height="15" fill="rgb(206,111,30)" fg:x="11130" fg:w="4"/><text x="28.9112%" y="415.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (7 samples, 0.02%)</title><rect x="28.6560%" y="453" width="0.0180%" height="15" fill="rgb(243,70,54)" fg:x="11128" fg:w="7"/><text x="28.9060%" y="463.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::get_unchecked_ptr (6 samples, 0.02%)</title><rect x="28.6818%" y="405" width="0.0155%" height="15" fill="rgb(242,28,8)" fg:x="11138" fg:w="6"/><text x="28.9318%" y="415.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::add (6 samples, 0.02%)</title><rect x="28.6818%" y="389" width="0.0155%" height="15" fill="rgb(219,106,18)" fg:x="11138" fg:w="6"/><text x="28.9318%" y="399.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::offset (6 samples, 0.02%)</title><rect x="28.6818%" y="373" width="0.0155%" height="15" fill="rgb(244,222,10)" fg:x="11138" fg:w="6"/><text x="28.9318%" y="383.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (253 samples, 0.65%)</title><rect x="28.6741%" y="453" width="0.6515%" height="15" fill="rgb(236,179,52)" fg:x="11135" fg:w="253"/><text x="28.9241%" y="463.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (253 samples, 0.65%)</title><rect x="28.6741%" y="437" width="0.6515%" height="15" fill="rgb(213,23,39)" fg:x="11135" fg:w="253"/><text x="28.9241%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (250 samples, 0.64%)</title><rect x="28.6818%" y="421" width="0.6438%" height="15" fill="rgb(238,48,10)" fg:x="11138" fg:w="250"/><text x="28.9318%" y="431.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (244 samples, 0.63%)</title><rect x="28.6972%" y="405" width="0.6283%" height="15" fill="rgb(251,196,23)" fg:x="11144" fg:w="244"/><text x="28.9472%" y="415.50"></text></g><g><title>[libc.so.6] (242 samples, 0.62%)</title><rect x="28.7024%" y="389" width="0.6232%" height="15" fill="rgb(250,152,24)" fg:x="11146" fg:w="242"/><text x="28.9524%" y="399.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::update (15 samples, 0.04%)</title><rect x="29.3256%" y="453" width="0.0386%" height="15" fill="rgb(209,150,17)" fg:x="11388" fg:w="15"/><text x="29.5756%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_max (15 samples, 0.04%)</title><rect x="29.3256%" y="437" width="0.0386%" height="15" fill="rgb(234,202,34)" fg:x="11388" fg:w="15"/><text x="29.5756%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_umax (15 samples, 0.04%)</title><rect x="29.3256%" y="421" width="0.0386%" height="15" fill="rgb(253,148,53)" fg:x="11388" fg:w="15"/><text x="29.5756%" y="431.50"></text></g><g><title>zssp::zeta::receive_payload_in_place (5,655 samples, 14.56%)</title><rect x="14.8070%" y="469" width="14.5624%" height="15" fill="rgb(218,129,16)" fg:x="5750" fg:w="5655"/><text x="15.0570%" y="479.50">zssp::zeta::receive_pa..</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8,525 samples, 21.95%)</title><rect x="7.6069%" y="485" width="21.9530%" height="15" fill="rgb(216,85,19)" fg:x="2954" fg:w="8525"/><text x="7.8569%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::receive</text></g><g><title>zssp::zssp::parse_fragment_header (74 samples, 0.19%)</title><rect x="29.3694%" y="469" width="0.1906%" height="15" fill="rgb(235,228,7)" fg:x="11405" fg:w="74"/><text x="29.6194%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (60 samples, 0.15%)</title><rect x="29.6166%" y="437" width="0.1545%" height="15" fill="rgb(245,175,0)" fg:x="11501" fg:w="60"/><text x="29.8666%" y="447.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (60 samples, 0.15%)</title><rect x="29.6166%" y="421" width="0.1545%" height="15" fill="rgb(208,168,36)" fg:x="11501" fg:w="60"/><text x="29.8666%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (59 samples, 0.15%)</title><rect x="29.6191%" y="405" width="0.1519%" height="15" fill="rgb(246,171,24)" fg:x="11502" fg:w="59"/><text x="29.8691%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (54 samples, 0.14%)</title><rect x="29.6320%" y="389" width="0.1391%" height="15" fill="rgb(215,142,24)" fg:x="11507" fg:w="54"/><text x="29.8820%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_swap (54 samples, 0.14%)</title><rect x="29.6320%" y="373" width="0.1391%" height="15" fill="rgb(250,187,7)" fg:x="11507" fg:w="54"/><text x="29.8820%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (79 samples, 0.20%)</title><rect x="29.7711%" y="437" width="0.2034%" height="15" fill="rgb(228,66,33)" fg:x="11561" fg:w="79"/><text x="30.0211%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (77 samples, 0.20%)</title><rect x="29.7762%" y="421" width="0.1983%" height="15" fill="rgb(234,215,21)" fg:x="11563" fg:w="77"/><text x="30.0262%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (74 samples, 0.19%)</title><rect x="29.7839%" y="405" width="0.1906%" height="15" fill="rgb(222,191,20)" fg:x="11566" fg:w="74"/><text x="30.0339%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (74 samples, 0.19%)</title><rect x="29.7839%" y="389" width="0.1906%" height="15" fill="rgb(245,79,54)" fg:x="11566" fg:w="74"/><text x="30.0339%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (325 samples, 0.84%)</title><rect x="29.6011%" y="453" width="0.8369%" height="15" fill="rgb(240,10,37)" fg:x="11495" fg:w="325"/><text x="29.8511%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (180 samples, 0.46%)</title><rect x="29.9745%" y="437" width="0.4635%" height="15" fill="rgb(214,192,32)" fg:x="11640" fg:w="180"/><text x="30.2245%" y="447.50"></text></g><g><title>EVP_EncryptUpdate (180 samples, 0.46%)</title><rect x="29.9745%" y="421" width="0.4635%" height="15" fill="rgb(209,36,54)" fg:x="11640" fg:w="180"/><text x="30.2245%" y="431.50"></text></g><g><title>[libcrypto.so.3] (154 samples, 0.40%)</title><rect x="30.0415%" y="405" width="0.3966%" height="15" fill="rgb(220,10,11)" fg:x="11666" fg:w="154"/><text x="30.2915%" y="415.50"></text></g><g><title>[libcrypto.so.3] (123 samples, 0.32%)</title><rect x="30.1213%" y="389" width="0.3167%" height="15" fill="rgb(221,106,17)" fg:x="11697" fg:w="123"/><text x="30.3713%" y="399.50"></text></g><g><title>[libcrypto.so.3] (115 samples, 0.30%)</title><rect x="30.1419%" y="373" width="0.2961%" height="15" fill="rgb(251,142,44)" fg:x="11705" fg:w="115"/><text x="30.3919%" y="383.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::deref::Deref&gt;::deref (5 samples, 0.01%)</title><rect x="30.4380%" y="437" width="0.0129%" height="15" fill="rgb(238,13,15)" fg:x="11820" fg:w="5"/><text x="30.6880%" y="447.50"></text></g><g><title>CRYPTO_gcm128_encrypt (264 samples, 0.68%)</title><rect x="30.7419%" y="357" width="0.6798%" height="15" fill="rgb(208,107,27)" fg:x="11938" fg:w="264"/><text x="30.9919%" y="367.50"></text></g><g><title>[libcrypto.so.3] (144 samples, 0.37%)</title><rect x="31.0509%" y="341" width="0.3708%" height="15" fill="rgb(205,136,37)" fg:x="12058" fg:w="144"/><text x="31.3009%" y="351.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="32.6475%" y="325" width="0.0515%" height="15" fill="rgb(250,205,27)" fg:x="12678" fg:w="20"/><text x="32.8975%" y="335.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (501 samples, 1.29%)</title><rect x="31.4217%" y="357" width="1.2901%" height="15" fill="rgb(210,80,43)" fg:x="12202" fg:w="501"/><text x="31.6717%" y="367.50"></text></g><g><title>[libcrypto.so.3] (349 samples, 0.90%)</title><rect x="31.8131%" y="341" width="0.8987%" height="15" fill="rgb(247,160,36)" fg:x="12354" fg:w="349"/><text x="32.0631%" y="351.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="32.6990%" y="325" width="0.0129%" height="15" fill="rgb(234,13,49)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="32.6990%" y="309" width="0.0129%" height="15" fill="rgb(234,122,0)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="32.6990%" y="293" width="0.0129%" height="15" fill="rgb(207,146,38)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="32.6990%" y="277" width="0.0129%" height="15" fill="rgb(207,177,25)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="32.6990%" y="261" width="0.0129%" height="15" fill="rgb(211,178,42)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="32.6990%" y="245" width="0.0129%" height="15" fill="rgb(230,69,54)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="32.6990%" y="229" width="0.0129%" height="15" fill="rgb(214,135,41)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="32.6990%" y="213" width="0.0129%" height="15" fill="rgb(237,67,25)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="32.6990%" y="197" width="0.0129%" height="15" fill="rgb(222,189,50)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="32.6990%" y="181" width="0.0129%" height="15" fill="rgb(245,148,34)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="191.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="32.6990%" y="165" width="0.0129%" height="15" fill="rgb(222,29,6)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="175.50"></text></g><g><title>CRYPTO_gcm128_setiv (23 samples, 0.06%)</title><rect x="32.7119%" y="357" width="0.0592%" height="15" fill="rgb(221,189,43)" fg:x="12703" fg:w="23"/><text x="32.9619%" y="367.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="32.7196%" y="341" width="0.0515%" height="15" fill="rgb(207,36,27)" fg:x="12706" fg:w="20"/><text x="32.9696%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (3,870 samples, 9.97%)</title><rect x="30.4380%" y="453" width="9.9658%" height="15" fill="rgb(217,90,24)" fg:x="11820" fg:w="3870"/><text x="30.6880%" y="463.50">&lt;zssp::crypto_..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (3,865 samples, 9.95%)</title><rect x="30.4509%" y="437" width="9.9529%" height="15" fill="rgb(224,66,35)" fg:x="11825" fg:w="3865"/><text x="30.7009%" y="447.50">zssp::crypto_i..</text></g><g><title>EVP_EncryptUpdate (3,859 samples, 9.94%)</title><rect x="30.4664%" y="421" width="9.9374%" height="15" fill="rgb(221,13,50)" fg:x="11831" fg:w="3859"/><text x="30.7164%" y="431.50">EVP_EncryptUpd..</text></g><g><title>[libcrypto.so.3] (3,809 samples, 9.81%)</title><rect x="30.5951%" y="405" width="9.8087%" height="15" fill="rgb(236,68,49)" fg:x="11881" fg:w="3809"/><text x="30.8451%" y="415.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,805 samples, 9.80%)</title><rect x="30.6054%" y="389" width="9.7984%" height="15" fill="rgb(229,146,28)" fg:x="11885" fg:w="3805"/><text x="30.8554%" y="399.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,789 samples, 9.76%)</title><rect x="30.6466%" y="373" width="9.7572%" height="15" fill="rgb(225,31,38)" fg:x="11901" fg:w="3789"/><text x="30.8966%" y="383.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (2,964 samples, 7.63%)</title><rect x="32.7711%" y="357" width="7.6327%" height="15" fill="rgb(250,208,3)" fg:x="12726" fg:w="2964"/><text x="33.0211%" y="367.50">[libcrypto..</text></g><g><title>[libcrypto.so.3] (2,713 samples, 6.99%)</title><rect x="33.4175%" y="341" width="6.9863%" height="15" fill="rgb(246,54,23)" fg:x="12977" fg:w="2713"/><text x="33.6675%" y="351.50">[libcrypt..</text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="40.3909%" y="325" width="0.0129%" height="15" fill="rgb(243,76,11)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="40.3909%" y="309" width="0.0129%" height="15" fill="rgb(245,21,50)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="40.3909%" y="293" width="0.0129%" height="15" fill="rgb(228,9,43)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="40.3909%" y="277" width="0.0129%" height="15" fill="rgb(208,100,47)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="40.3909%" y="261" width="0.0129%" height="15" fill="rgb(232,26,8)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="40.3909%" y="245" width="0.0129%" height="15" fill="rgb(216,166,38)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="40.3909%" y="229" width="0.0129%" height="15" fill="rgb(251,202,51)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="40.3909%" y="213" width="0.0129%" height="15" fill="rgb(254,216,34)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="40.3909%" y="197" width="0.0129%" height="15" fill="rgb(251,32,27)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="40.3909%" y="181" width="0.0129%" height="15" fill="rgb(208,127,28)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="191.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="40.3909%" y="165" width="0.0129%" height="15" fill="rgb(224,137,22)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="175.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc&gt; (7 samples, 0.02%)</title><rect x="40.4064%" y="437" width="0.0180%" height="15" fill="rgb(254,70,32)" fg:x="15691" fg:w="7"/><text x="40.6564%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (7 samples, 0.02%)</title><rect x="40.4064%" y="421" width="0.0180%" height="15" fill="rgb(229,75,37)" fg:x="15691" fg:w="7"/><text x="40.6564%" y="431.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="40.4064%" y="405" width="0.0180%" height="15" fill="rgb(252,64,23)" fg:x="15691" fg:w="7"/><text x="40.6564%" y="415.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (6 samples, 0.02%)</title><rect x="40.4089%" y="389" width="0.0155%" height="15" fill="rgb(232,162,48)" fg:x="15692" fg:w="6"/><text x="40.6589%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (6 samples, 0.02%)</title><rect x="40.4089%" y="373" width="0.0155%" height="15" fill="rgb(246,160,12)" fg:x="15692" fg:w="6"/><text x="40.6589%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_swap (6 samples, 0.02%)</title><rect x="40.4089%" y="357" width="0.0155%" height="15" fill="rgb(247,166,0)" fg:x="15692" fg:w="6"/><text x="40.6589%" y="367.50"></text></g><g><title>[libcrypto.so.3] (31 samples, 0.08%)</title><rect x="40.5300%" y="325" width="0.0798%" height="15" fill="rgb(249,219,21)" fg:x="15739" fg:w="31"/><text x="40.7800%" y="335.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (75 samples, 0.19%)</title><rect x="40.4244%" y="437" width="0.1931%" height="15" fill="rgb(205,209,3)" fg:x="15698" fg:w="75"/><text x="40.6744%" y="447.50"></text></g><g><title>EVP_EncryptFinal_ex (75 samples, 0.19%)</title><rect x="40.4244%" y="421" width="0.1931%" height="15" fill="rgb(243,44,1)" fg:x="15698" fg:w="75"/><text x="40.6744%" y="431.50"></text></g><g><title>[libcrypto.so.3] (61 samples, 0.16%)</title><rect x="40.4604%" y="405" width="0.1571%" height="15" fill="rgb(206,159,16)" fg:x="15712" fg:w="61"/><text x="40.7104%" y="415.50"></text></g><g><title>[libcrypto.so.3] (59 samples, 0.15%)</title><rect x="40.4656%" y="389" width="0.1519%" height="15" fill="rgb(244,77,30)" fg:x="15714" fg:w="59"/><text x="40.7156%" y="399.50"></text></g><g><title>[libcrypto.so.3] (56 samples, 0.14%)</title><rect x="40.4733%" y="373" width="0.1442%" height="15" fill="rgb(218,69,12)" fg:x="15717" fg:w="56"/><text x="40.7233%" y="383.50"></text></g><g><title>CRYPTO_gcm128_tag (55 samples, 0.14%)</title><rect x="40.4759%" y="357" width="0.1416%" height="15" fill="rgb(212,87,7)" fg:x="15718" fg:w="55"/><text x="40.7259%" y="367.50"></text></g><g><title>CRYPTO_gcm128_finish (42 samples, 0.11%)</title><rect x="40.5094%" y="341" width="0.1082%" height="15" fill="rgb(245,114,25)" fg:x="15731" fg:w="42"/><text x="40.7594%" y="351.50"></text></g><g><title>[libc.so.6] (29 samples, 0.07%)</title><rect x="40.7694%" y="373" width="0.0747%" height="15" fill="rgb(210,61,42)" fg:x="15832" fg:w="29"/><text x="41.0194%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (60 samples, 0.15%)</title><rect x="40.6922%" y="389" width="0.1545%" height="15" fill="rgb(211,52,33)" fg:x="15802" fg:w="60"/><text x="40.9422%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::finish (177 samples, 0.46%)</title><rect x="40.4038%" y="453" width="0.4558%" height="15" fill="rgb(234,58,33)" fg:x="15690" fg:w="177"/><text x="40.6538%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::get_tag (94 samples, 0.24%)</title><rect x="40.6175%" y="437" width="0.2421%" height="15" fill="rgb(220,115,36)" fg:x="15773" fg:w="94"/><text x="40.8675%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (94 samples, 0.24%)</title><rect x="40.6175%" y="421" width="0.2421%" height="15" fill="rgb(243,153,54)" fg:x="15773" fg:w="94"/><text x="40.8675%" y="431.50"></text></g><g><title>[libcrypto.so.3] (69 samples, 0.18%)</title><rect x="40.6819%" y="405" width="0.1777%" height="15" fill="rgb(251,47,18)" fg:x="15798" fg:w="69"/><text x="40.9319%" y="415.50"></text></g><g><title>OSSL_PARAM_set_octet_string (5 samples, 0.01%)</title><rect x="40.8467%" y="389" width="0.0129%" height="15" fill="rgb(242,102,42)" fg:x="15862" fg:w="5"/><text x="41.0967%" y="399.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="40.8467%" y="373" width="0.0129%" height="15" fill="rgb(234,31,38)" fg:x="15862" fg:w="5"/><text x="41.0967%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (15 samples, 0.04%)</title><rect x="40.8596%" y="437" width="0.0386%" height="15" fill="rgb(221,117,51)" fg:x="15867" fg:w="15"/><text x="41.1096%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (13 samples, 0.03%)</title><rect x="40.8647%" y="421" width="0.0335%" height="15" fill="rgb(212,20,18)" fg:x="15869" fg:w="13"/><text x="41.1147%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (11 samples, 0.03%)</title><rect x="40.8699%" y="405" width="0.0283%" height="15" fill="rgb(245,133,36)" fg:x="15871" fg:w="11"/><text x="41.1199%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (11 samples, 0.03%)</title><rect x="40.8699%" y="389" width="0.0283%" height="15" fill="rgb(212,6,19)" fg:x="15871" fg:w="11"/><text x="41.1199%" y="399.50"></text></g><g><title>[libc.so.6] (25 samples, 0.06%)</title><rect x="41.1016%" y="341" width="0.0644%" height="15" fill="rgb(218,1,36)" fg:x="15961" fg:w="25"/><text x="41.3516%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (76 samples, 0.20%)</title><rect x="40.9755%" y="389" width="0.1957%" height="15" fill="rgb(246,84,54)" fg:x="15912" fg:w="76"/><text x="41.2255%" y="399.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="41.0347%" y="373" width="0.1365%" height="15" fill="rgb(242,110,6)" fg:x="15935" fg:w="53"/><text x="41.2847%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (46 samples, 0.12%)</title><rect x="41.0527%" y="357" width="0.1185%" height="15" fill="rgb(214,47,5)" fg:x="15942" fg:w="46"/><text x="41.3027%" y="367.50"></text></g><g><title>[libc.so.6] (37 samples, 0.10%)</title><rect x="41.2948%" y="341" width="0.0953%" height="15" fill="rgb(218,159,25)" fg:x="16036" fg:w="37"/><text x="41.5448%" y="351.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="41.3772%" y="325" width="0.0129%" height="15" fill="rgb(215,211,28)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="41.3772%" y="309" width="0.0129%" height="15" fill="rgb(238,59,32)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="41.3772%" y="293" width="0.0129%" height="15" fill="rgb(226,82,3)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="41.3772%" y="277" width="0.0129%" height="15" fill="rgb(240,164,32)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="41.3772%" y="261" width="0.0129%" height="15" fill="rgb(232,46,7)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="41.3772%" y="245" width="0.0129%" height="15" fill="rgb(229,129,53)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="41.3772%" y="229" width="0.0129%" height="15" fill="rgb(234,188,29)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="41.3772%" y="213" width="0.0129%" height="15" fill="rgb(246,141,4)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="41.3772%" y="197" width="0.0129%" height="15" fill="rgb(229,23,39)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="41.3772%" y="181" width="0.0129%" height="15" fill="rgb(206,12,3)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="191.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="41.3772%" y="165" width="0.0129%" height="15" fill="rgb(252,226,20)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="175.50"></text></g><g><title>OSSL_PARAM_locate (49 samples, 0.13%)</title><rect x="41.2767%" y="357" width="0.1262%" height="15" fill="rgb(216,123,35)" fg:x="16029" fg:w="49"/><text x="41.5267%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="41.3901%" y="341" width="0.0129%" height="15" fill="rgb(212,68,40)" fg:x="16073" fg:w="5"/><text x="41.6401%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (95 samples, 0.24%)</title><rect x="41.1712%" y="389" width="0.2446%" height="15" fill="rgb(254,125,32)" fg:x="15988" fg:w="95"/><text x="41.4212%" y="399.50"></text></g><g><title>[libcrypto.so.3] (62 samples, 0.16%)</title><rect x="41.2561%" y="373" width="0.1597%" height="15" fill="rgb(253,97,22)" fg:x="16021" fg:w="62"/><text x="41.5061%" y="383.50"></text></g><g><title>OSSL_PARAM_locate_const (5 samples, 0.01%)</title><rect x="41.4029%" y="357" width="0.0129%" height="15" fill="rgb(241,101,14)" fg:x="16078" fg:w="5"/><text x="41.6529%" y="367.50"></text></g><g><title>EVP_CIPHER_free (14 samples, 0.04%)</title><rect x="41.4158%" y="389" width="0.0361%" height="15" fill="rgb(238,103,29)" fg:x="16083" fg:w="14"/><text x="41.6658%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (28 samples, 0.07%)</title><rect x="41.4519%" y="389" width="0.0721%" height="15" fill="rgb(233,195,47)" fg:x="16097" fg:w="28"/><text x="41.7019%" y="399.50"></text></g><g><title>EVP_CipherInit_ex (245 samples, 0.63%)</title><rect x="40.8982%" y="421" width="0.6309%" height="15" fill="rgb(246,218,30)" fg:x="15882" fg:w="245"/><text x="41.1482%" y="431.50"></text></g><g><title>[libcrypto.so.3] (245 samples, 0.63%)</title><rect x="40.8982%" y="405" width="0.6309%" height="15" fill="rgb(219,145,47)" fg:x="15882" fg:w="245"/><text x="41.1482%" y="415.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (262 samples, 0.67%)</title><rect x="40.8596%" y="453" width="0.6747%" height="15" fill="rgb(243,12,26)" fg:x="15867" fg:w="262"/><text x="41.1096%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (247 samples, 0.64%)</title><rect x="40.8982%" y="437" width="0.6361%" height="15" fill="rgb(214,87,16)" fg:x="15882" fg:w="247"/><text x="41.1482%" y="447.50"></text></g><g><title>__rdl_alloc (10 samples, 0.03%)</title><rect x="41.5420%" y="277" width="0.0258%" height="15" fill="rgb(208,99,42)" fg:x="16132" fg:w="10"/><text x="41.7920%" y="287.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::alloc (10 samples, 0.03%)</title><rect x="41.5420%" y="261" width="0.0258%" height="15" fill="rgb(253,99,2)" fg:x="16132" fg:w="10"/><text x="41.7920%" y="271.50"></text></g><g><title>__rust_alloc (5 samples, 0.01%)</title><rect x="41.5677%" y="277" width="0.0129%" height="15" fill="rgb(220,168,23)" fg:x="16142" fg:w="5"/><text x="41.8177%" y="287.50"></text></g><g><title>[libc.so.6] (74 samples, 0.19%)</title><rect x="46.1489%" y="245" width="0.1906%" height="15" fill="rgb(242,38,24)" fg:x="17921" fg:w="74"/><text x="46.3989%" y="255.50"></text></g><g><title>asm_exc_page_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="229" width="0.0129%" height="15" fill="rgb(225,182,9)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="239.50"></text></g><g><title>exc_page_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="213" width="0.0129%" height="15" fill="rgb(243,178,37)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="223.50"></text></g><g><title>do_user_addr_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="197" width="0.0129%" height="15" fill="rgb(232,139,19)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="207.50"></text></g><g><title>handle_mm_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="181" width="0.0129%" height="15" fill="rgb(225,201,24)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="191.50"></text></g><g><title>__handle_mm_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="165" width="0.0129%" height="15" fill="rgb(221,47,46)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="175.50"></text></g><g><title>handle_pte_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="149" width="0.0129%" height="15" fill="rgb(249,23,13)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="159.50"></text></g><g><title>do_anonymous_page (5 samples, 0.01%)</title><rect x="46.3266%" y="133" width="0.0129%" height="15" fill="rgb(219,9,5)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="143.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="46.3446%" y="85" width="0.0129%" height="15" fill="rgb(254,171,16)" fg:x="17997" fg:w="5"/><text x="46.5946%" y="95.50"></text></g><g><title>finish_task_switch.isra.0 (13 samples, 0.03%)</title><rect x="46.3446%" y="117" width="0.0335%" height="15" fill="rgb(230,171,20)" fg:x="17997" fg:w="13"/><text x="46.5946%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (13 samples, 0.03%)</title><rect x="46.3446%" y="101" width="0.0335%" height="15" fill="rgb(210,71,41)" fg:x="17997" fg:w="13"/><text x="46.5946%" y="111.50"></text></g><g><title>perf_pmu_nop_void (8 samples, 0.02%)</title><rect x="46.3575%" y="85" width="0.0206%" height="15" fill="rgb(206,173,20)" fg:x="18002" fg:w="8"/><text x="46.6075%" y="95.50"></text></g><g><title>[libc.so.6] (1,111 samples, 2.86%)</title><rect x="43.5197%" y="261" width="2.8610%" height="15" fill="rgb(233,88,34)" fg:x="16900" fg:w="1111"/><text x="43.7697%" y="271.50">[l..</text></g><g><title>asm_sysvec_reschedule_ipi (16 samples, 0.04%)</title><rect x="46.3395%" y="245" width="0.0412%" height="15" fill="rgb(223,209,46)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="255.50"></text></g><g><title>sysvec_reschedule_ipi (16 samples, 0.04%)</title><rect x="46.3395%" y="229" width="0.0412%" height="15" fill="rgb(250,43,18)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="239.50"></text></g><g><title>irqentry_exit (16 samples, 0.04%)</title><rect x="46.3395%" y="213" width="0.0412%" height="15" fill="rgb(208,13,10)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="223.50"></text></g><g><title>irqentry_exit_to_user_mode (16 samples, 0.04%)</title><rect x="46.3395%" y="197" width="0.0412%" height="15" fill="rgb(212,200,36)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (16 samples, 0.04%)</title><rect x="46.3395%" y="181" width="0.0412%" height="15" fill="rgb(225,90,30)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="191.50"></text></g><g><title>exit_to_user_mode_loop (16 samples, 0.04%)</title><rect x="46.3395%" y="165" width="0.0412%" height="15" fill="rgb(236,182,39)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="175.50"></text></g><g><title>schedule (14 samples, 0.04%)</title><rect x="46.3446%" y="149" width="0.0361%" height="15" fill="rgb(212,144,35)" fg:x="17997" fg:w="14"/><text x="46.5946%" y="159.50"></text></g><g><title>__schedule (14 samples, 0.04%)</title><rect x="46.3446%" y="133" width="0.0361%" height="15" fill="rgb(228,63,44)" fg:x="17997" fg:w="14"/><text x="46.5946%" y="143.50"></text></g><g><title>__entry_text_start (10 samples, 0.03%)</title><rect x="46.4502%" y="245" width="0.0258%" height="15" fill="rgb(228,109,6)" fg:x="18038" fg:w="10"/><text x="46.7002%" y="255.50"></text></g><g><title>__get_user_nocheck_4 (9 samples, 0.02%)</title><rect x="46.5120%" y="149" width="0.0232%" height="15" fill="rgb(238,117,24)" fg:x="18062" fg:w="9"/><text x="46.7620%" y="159.50"></text></g><g><title>_raw_spin_lock (6 samples, 0.02%)</title><rect x="46.5352%" y="149" width="0.0155%" height="15" fill="rgb(242,26,26)" fg:x="18071" fg:w="6"/><text x="46.7852%" y="159.50"></text></g><g><title>futex_q_lock (10 samples, 0.03%)</title><rect x="46.5583%" y="149" width="0.0258%" height="15" fill="rgb(221,92,48)" fg:x="18080" fg:w="10"/><text x="46.8083%" y="159.50"></text></g><g><title>futex_q_unlock (12 samples, 0.03%)</title><rect x="46.5841%" y="149" width="0.0309%" height="15" fill="rgb(209,209,32)" fg:x="18090" fg:w="12"/><text x="46.8341%" y="159.50"></text></g><g><title>futex_wait_setup (44 samples, 0.11%)</title><rect x="46.5120%" y="165" width="0.1133%" height="15" fill="rgb(221,70,22)" fg:x="18062" fg:w="44"/><text x="46.7620%" y="175.50"></text></g><g><title>get_futex_key (4 samples, 0.01%)</title><rect x="46.6150%" y="149" width="0.0103%" height="15" fill="rgb(248,145,5)" fg:x="18102" fg:w="4"/><text x="46.8650%" y="159.50"></text></g><g><title>futex_wait (52 samples, 0.13%)</title><rect x="46.4940%" y="181" width="0.1339%" height="15" fill="rgb(226,116,26)" fg:x="18055" fg:w="52"/><text x="46.7440%" y="191.50"></text></g><g><title>__x64_sys_futex (57 samples, 0.15%)</title><rect x="46.4837%" y="213" width="0.1468%" height="15" fill="rgb(244,5,17)" fg:x="18051" fg:w="57"/><text x="46.7337%" y="223.50"></text></g><g><title>do_futex (54 samples, 0.14%)</title><rect x="46.4914%" y="197" width="0.1391%" height="15" fill="rgb(252,159,33)" fg:x="18054" fg:w="54"/><text x="46.7414%" y="207.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (62 samples, 0.16%)</title><rect x="46.4785%" y="245" width="0.1597%" height="15" fill="rgb(206,71,0)" fg:x="18049" fg:w="62"/><text x="46.7285%" y="255.50"></text></g><g><title>do_syscall_64 (60 samples, 0.15%)</title><rect x="46.4837%" y="229" width="0.1545%" height="15" fill="rgb(233,118,54)" fg:x="18051" fg:w="60"/><text x="46.7337%" y="239.50"></text></g><g><title>__lll_lock_wait_private (101 samples, 0.26%)</title><rect x="46.3807%" y="261" width="0.2601%" height="15" fill="rgb(234,83,48)" fg:x="18011" fg:w="101"/><text x="46.6307%" y="271.50"></text></g><g><title>__entry_text_start (7 samples, 0.02%)</title><rect x="46.6536%" y="245" width="0.0180%" height="15" fill="rgb(228,3,54)" fg:x="18117" fg:w="7"/><text x="46.9036%" y="255.50"></text></g><g><title>_raw_spin_lock (9 samples, 0.02%)</title><rect x="46.7000%" y="181" width="0.0232%" height="15" fill="rgb(226,155,13)" fg:x="18135" fg:w="9"/><text x="46.9500%" y="191.50"></text></g><g><title>_raw_spin_lock (12 samples, 0.03%)</title><rect x="46.8880%" y="165" width="0.0309%" height="15" fill="rgb(241,28,37)" fg:x="18208" fg:w="12"/><text x="47.1380%" y="175.50"></text></g><g><title>native_queued_spin_lock_slowpath (12 samples, 0.03%)</title><rect x="46.8880%" y="149" width="0.0309%" height="15" fill="rgb(233,93,10)" fg:x="18208" fg:w="12"/><text x="47.1380%" y="159.50"></text></g><g><title>futex_wake_mark (24 samples, 0.06%)</title><rect x="46.9189%" y="165" width="0.0618%" height="15" fill="rgb(225,113,19)" fg:x="18220" fg:w="24"/><text x="47.1689%" y="175.50"></text></g><g><title>__futex_unqueue (4 samples, 0.01%)</title><rect x="46.9704%" y="149" width="0.0103%" height="15" fill="rgb(241,2,18)" fg:x="18240" fg:w="4"/><text x="47.2204%" y="159.50"></text></g><g><title>__smp_call_single_queue (20 samples, 0.05%)</title><rect x="47.1223%" y="117" width="0.0515%" height="15" fill="rgb(228,207,21)" fg:x="18299" fg:w="20"/><text x="47.3723%" y="127.50"></text></g><g><title>native_send_call_func_single_ipi (17 samples, 0.04%)</title><rect x="47.1300%" y="101" width="0.0438%" height="15" fill="rgb(213,211,35)" fg:x="18302" fg:w="17"/><text x="47.3800%" y="111.50"></text></g><g><title>x2apic_send_IPI (17 samples, 0.04%)</title><rect x="47.1300%" y="85" width="0.0438%" height="15" fill="rgb(209,83,10)" fg:x="18302" fg:w="17"/><text x="47.3800%" y="95.50"></text></g><g><title>native_write_msr (15 samples, 0.04%)</title><rect x="47.1352%" y="69" width="0.0386%" height="15" fill="rgb(209,164,1)" fg:x="18304" fg:w="15"/><text x="47.3852%" y="79.50"></text></g><g><title>llist_add_batch (17 samples, 0.04%)</title><rect x="47.1764%" y="117" width="0.0438%" height="15" fill="rgb(213,184,43)" fg:x="18320" fg:w="17"/><text x="47.4264%" y="127.50"></text></g><g><title>try_to_wake_up (89 samples, 0.23%)</title><rect x="47.0013%" y="149" width="0.2292%" height="15" fill="rgb(231,61,34)" fg:x="18252" fg:w="89"/><text x="47.2513%" y="159.50"></text></g><g><title>ttwu_queue_wakelist (55 samples, 0.14%)</title><rect x="47.0888%" y="133" width="0.1416%" height="15" fill="rgb(235,75,3)" fg:x="18286" fg:w="55"/><text x="47.3388%" y="143.50"></text></g><g><title>futex_wake (196 samples, 0.50%)</title><rect x="46.7283%" y="181" width="0.5047%" height="15" fill="rgb(220,106,47)" fg:x="18146" fg:w="196"/><text x="46.9783%" y="191.50"></text></g><g><title>wake_up_q (96 samples, 0.25%)</title><rect x="46.9858%" y="165" width="0.2472%" height="15" fill="rgb(210,196,33)" fg:x="18246" fg:w="96"/><text x="47.2358%" y="175.50"></text></g><g><title>do_futex (210 samples, 0.54%)</title><rect x="46.6948%" y="197" width="0.5408%" height="15" fill="rgb(229,154,42)" fg:x="18133" fg:w="210"/><text x="46.9448%" y="207.50"></text></g><g><title>__x64_sys_futex (214 samples, 0.55%)</title><rect x="46.6897%" y="213" width="0.5511%" height="15" fill="rgb(228,114,26)" fg:x="18131" fg:w="214"/><text x="46.9397%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (224 samples, 0.58%)</title><rect x="46.6768%" y="245" width="0.5768%" height="15" fill="rgb(208,144,1)" fg:x="18126" fg:w="224"/><text x="46.9268%" y="255.50"></text></g><g><title>do_syscall_64 (222 samples, 0.57%)</title><rect x="46.6819%" y="229" width="0.5717%" height="15" fill="rgb(239,112,37)" fg:x="18128" fg:w="222"/><text x="46.9319%" y="239.50"></text></g><g><title>__lll_lock_wake_private (239 samples, 0.62%)</title><rect x="46.6407%" y="261" width="0.6155%" height="15" fill="rgb(210,96,50)" fg:x="18112" fg:w="239"/><text x="46.8907%" y="271.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (2,224 samples, 5.73%)</title><rect x="41.5343%" y="373" width="5.7271%" height="15" fill="rgb(222,178,2)" fg:x="16129" fg:w="2224"/><text x="41.7843%" y="383.50">alloc::..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (2,224 samples, 5.73%)</title><rect x="41.5343%" y="357" width="5.7271%" height="15" fill="rgb(226,74,18)" fg:x="16129" fg:w="2224"/><text x="41.7843%" y="367.50">alloc::..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (2,224 samples, 5.73%)</title><rect x="41.5343%" y="341" width="5.7271%" height="15" fill="rgb(225,67,54)" fg:x="16129" fg:w="2224"/><text x="41.7843%" y="351.50">alloc::..</text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (2,221 samples, 5.72%)</title><rect x="41.5420%" y="325" width="5.7194%" height="15" fill="rgb(251,92,32)" fg:x="16132" fg:w="2221"/><text x="41.7920%" y="335.50">&lt;alloc:..</text></g><g><title>alloc::alloc::Global::alloc_impl (2,221 samples, 5.72%)</title><rect x="41.5420%" y="309" width="5.7194%" height="15" fill="rgb(228,149,22)" fg:x="16132" fg:w="2221"/><text x="41.7920%" y="319.50">alloc::..</text></g><g><title>alloc::alloc::alloc (2,221 samples, 5.72%)</title><rect x="41.5420%" y="293" width="5.7194%" height="15" fill="rgb(243,54,13)" fg:x="16132" fg:w="2221"/><text x="41.7920%" y="303.50">alloc::..</text></g><g><title>malloc (2,206 samples, 5.68%)</title><rect x="41.5806%" y="277" width="5.6807%" height="15" fill="rgb(243,180,28)" fg:x="16147" fg:w="2206"/><text x="41.8306%" y="287.50">malloc</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (2,451 samples, 6.31%)</title><rect x="41.5343%" y="437" width="6.3116%" height="15" fill="rgb(208,167,24)" fg:x="16129" fg:w="2451"/><text x="41.7843%" y="447.50">alloc::s..</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (2,451 samples, 6.31%)</title><rect x="41.5343%" y="421" width="6.3116%" height="15" fill="rgb(245,73,45)" fg:x="16129" fg:w="2451"/><text x="41.7843%" y="431.50">alloc::s..</text></g><g><title>alloc::slice::hack::to_vec (2,451 samples, 6.31%)</title><rect x="41.5343%" y="405" width="6.3116%" height="15" fill="rgb(237,203,48)" fg:x="16129" fg:w="2451"/><text x="41.7843%" y="415.50">alloc::s..</text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (2,451 samples, 6.31%)</title><rect x="41.5343%" y="389" width="6.3116%" height="15" fill="rgb(211,197,16)" fg:x="16129" fg:w="2451"/><text x="41.7843%" y="399.50">&lt;T as al..</text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (227 samples, 0.58%)</title><rect x="47.2613%" y="373" width="0.5846%" height="15" fill="rgb(243,99,51)" fg:x="18353" fg:w="227"/><text x="47.5113%" y="383.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (227 samples, 0.58%)</title><rect x="47.2613%" y="357" width="0.5846%" height="15" fill="rgb(215,123,29)" fg:x="18353" fg:w="227"/><text x="47.5113%" y="367.50"></text></g><g><title>[libc.so.6] (222 samples, 0.57%)</title><rect x="47.2742%" y="341" width="0.5717%" height="15" fill="rgb(239,186,37)" fg:x="18358" fg:w="222"/><text x="47.5242%" y="351.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (5 samples, 0.01%)</title><rect x="51.3790%" y="389" width="0.0129%" height="15" fill="rgb(252,136,39)" fg:x="19952" fg:w="5"/><text x="51.6290%" y="399.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (4 samples, 0.01%)</title><rect x="51.3944%" y="389" width="0.0103%" height="15" fill="rgb(223,213,32)" fg:x="19958" fg:w="4"/><text x="51.6444%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (80 samples, 0.21%)</title><rect x="51.4717%" y="373" width="0.2060%" height="15" fill="rgb(233,115,5)" fg:x="19988" fg:w="80"/><text x="51.7217%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (80 samples, 0.21%)</title><rect x="51.4717%" y="357" width="0.2060%" height="15" fill="rgb(207,226,44)" fg:x="19988" fg:w="80"/><text x="51.7217%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (113 samples, 0.29%)</title><rect x="51.4047%" y="389" width="0.2910%" height="15" fill="rgb(208,126,0)" fg:x="19962" fg:w="113"/><text x="51.6547%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (7 samples, 0.02%)</title><rect x="51.6777%" y="373" width="0.0180%" height="15" fill="rgb(244,66,21)" fg:x="20068" fg:w="7"/><text x="51.9277%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (7 samples, 0.02%)</title><rect x="51.6777%" y="357" width="0.0180%" height="15" fill="rgb(222,97,12)" fg:x="20068" fg:w="7"/><text x="51.9277%" y="367.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (6 samples, 0.02%)</title><rect x="51.7447%" y="261" width="0.0155%" height="15" fill="rgb(219,213,19)" fg:x="20094" fg:w="6"/><text x="51.9947%" y="271.50"></text></g><g><title>core::sync::atomic::atomic_swap (6 samples, 0.02%)</title><rect x="51.7447%" y="245" width="0.0155%" height="15" fill="rgb(252,169,30)" fg:x="20094" fg:w="6"/><text x="51.9947%" y="255.50"></text></g><g><title>futex_wake_mark (7 samples, 0.02%)</title><rect x="51.8090%" y="149" width="0.0180%" height="15" fill="rgb(206,32,51)" fg:x="20119" fg:w="7"/><text x="52.0590%" y="159.50"></text></g><g><title>__smp_call_single_queue (6 samples, 0.02%)</title><rect x="51.8966%" y="101" width="0.0155%" height="15" fill="rgb(250,172,42)" fg:x="20153" fg:w="6"/><text x="52.1466%" y="111.50"></text></g><g><title>__x64_sys_futex (57 samples, 0.15%)</title><rect x="51.7730%" y="197" width="0.1468%" height="15" fill="rgb(209,34,43)" fg:x="20105" fg:w="57"/><text x="52.0230%" y="207.50"></text></g><g><title>do_futex (57 samples, 0.15%)</title><rect x="51.7730%" y="181" width="0.1468%" height="15" fill="rgb(223,11,35)" fg:x="20105" fg:w="57"/><text x="52.0230%" y="191.50"></text></g><g><title>futex_wake (55 samples, 0.14%)</title><rect x="51.7781%" y="165" width="0.1416%" height="15" fill="rgb(251,219,26)" fg:x="20107" fg:w="55"/><text x="52.0281%" y="175.50"></text></g><g><title>wake_up_q (36 samples, 0.09%)</title><rect x="51.8271%" y="149" width="0.0927%" height="15" fill="rgb(231,119,3)" fg:x="20126" fg:w="36"/><text x="52.0771%" y="159.50"></text></g><g><title>try_to_wake_up (35 samples, 0.09%)</title><rect x="51.8296%" y="133" width="0.0901%" height="15" fill="rgb(216,97,11)" fg:x="20127" fg:w="35"/><text x="52.0796%" y="143.50"></text></g><g><title>ttwu_queue_wakelist (14 samples, 0.04%)</title><rect x="51.8837%" y="117" width="0.0361%" height="15" fill="rgb(223,59,9)" fg:x="20148" fg:w="14"/><text x="52.1337%" y="127.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (91 samples, 0.23%)</title><rect x="51.6957%" y="389" width="0.2343%" height="15" fill="rgb(233,93,31)" fg:x="20075" fg:w="91"/><text x="51.9457%" y="399.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (85 samples, 0.22%)</title><rect x="51.7112%" y="373" width="0.2189%" height="15" fill="rgb(239,81,33)" fg:x="20081" fg:w="85"/><text x="51.9612%" y="383.50"></text></g><g><title>std::sync::mpmc::waker::Waker::try_select (74 samples, 0.19%)</title><rect x="51.7395%" y="357" width="0.1906%" height="15" fill="rgb(213,120,34)" fg:x="20092" fg:w="74"/><text x="51.9895%" y="367.50"></text></g><g><title>&lt;core::slice::iter::Iter&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::position (74 samples, 0.19%)</title><rect x="51.7395%" y="341" width="0.1906%" height="15" fill="rgb(243,49,53)" fg:x="20092" fg:w="74"/><text x="51.9895%" y="351.50"></text></g><g><title>std::sync::mpmc::waker::Waker::try_select::_{{closure}} (74 samples, 0.19%)</title><rect x="51.7395%" y="325" width="0.1906%" height="15" fill="rgb(247,216,33)" fg:x="20092" fg:w="74"/><text x="51.9895%" y="335.50"></text></g><g><title>std::sync::mpmc::context::Context::unpark (72 samples, 0.19%)</title><rect x="51.7447%" y="309" width="0.1854%" height="15" fill="rgb(226,26,14)" fg:x="20094" fg:w="72"/><text x="51.9947%" y="319.50"></text></g><g><title>std::thread::Thread::unpark (72 samples, 0.19%)</title><rect x="51.7447%" y="293" width="0.1854%" height="15" fill="rgb(215,49,53)" fg:x="20094" fg:w="72"/><text x="51.9947%" y="303.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::unpark (72 samples, 0.19%)</title><rect x="51.7447%" y="277" width="0.1854%" height="15" fill="rgb(245,162,40)" fg:x="20094" fg:w="72"/><text x="51.9947%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wake (66 samples, 0.17%)</title><rect x="51.7601%" y="261" width="0.1700%" height="15" fill="rgb(229,68,17)" fg:x="20100" fg:w="66"/><text x="52.0101%" y="271.50"></text></g><g><title>syscall (66 samples, 0.17%)</title><rect x="51.7601%" y="245" width="0.1700%" height="15" fill="rgb(213,182,10)" fg:x="20100" fg:w="66"/><text x="52.0101%" y="255.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (61 samples, 0.16%)</title><rect x="51.7730%" y="229" width="0.1571%" height="15" fill="rgb(245,125,30)" fg:x="20105" fg:w="61"/><text x="52.0230%" y="239.50"></text></g><g><title>do_syscall_64 (61 samples, 0.16%)</title><rect x="51.7730%" y="213" width="0.1571%" height="15" fill="rgb(232,202,2)" fg:x="20105" fg:w="61"/><text x="52.0230%" y="223.50"></text></g><g><title>std::sync::mpmc::context::Context::wait_until (4 samples, 0.01%)</title><rect x="51.9301%" y="309" width="0.0103%" height="15" fill="rgb(237,140,51)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="319.50"></text></g><g><title>std::thread::park (4 samples, 0.01%)</title><rect x="51.9301%" y="293" width="0.0103%" height="15" fill="rgb(236,157,25)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="303.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::park (4 samples, 0.01%)</title><rect x="51.9301%" y="277" width="0.0103%" height="15" fill="rgb(219,209,0)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wait (4 samples, 0.01%)</title><rect x="51.9301%" y="261" width="0.0103%" height="15" fill="rgb(240,116,54)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="271.50"></text></g><g><title>syscall (4 samples, 0.01%)</title><rect x="51.9301%" y="245" width="0.0103%" height="15" fill="rgb(216,10,36)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="255.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (4 samples, 0.01%)</title><rect x="51.9301%" y="229" width="0.0103%" height="15" fill="rgb(222,72,44)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="239.50"></text></g><g><title>do_syscall_64 (4 samples, 0.01%)</title><rect x="51.9301%" y="213" width="0.0103%" height="15" fill="rgb(232,159,9)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="223.50"></text></g><g><title>std::sync::mpmc::context::Context::with (5 samples, 0.01%)</title><rect x="51.9301%" y="389" width="0.0129%" height="15" fill="rgb(210,39,32)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="399.50"></text></g><g><title>std::thread::local::LocalKey&lt;T&gt;::try_with (5 samples, 0.01%)</title><rect x="51.9301%" y="373" width="0.0129%" height="15" fill="rgb(216,194,45)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="383.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (5 samples, 0.01%)</title><rect x="51.9301%" y="357" width="0.0129%" height="15" fill="rgb(218,18,35)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="367.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (5 samples, 0.01%)</title><rect x="51.9301%" y="341" width="0.0129%" height="15" fill="rgb(207,83,51)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="351.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send::_{{closure}} (5 samples, 0.01%)</title><rect x="51.9301%" y="325" width="0.0129%" height="15" fill="rgb(225,63,43)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="335.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (4,067 samples, 10.47%)</title><rect x="41.5343%" y="453" width="10.4731%" height="15" fill="rgb(207,57,36)" fg:x="16129" fg:w="4067"/><text x="41.7843%" y="463.50">benchmark::bob_..</text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (1,615 samples, 4.16%)</title><rect x="47.8485%" y="437" width="4.1588%" height="15" fill="rgb(216,99,33)" fg:x="18581" fg:w="1615"/><text x="48.0985%" y="447.50">std::..</text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (1,613 samples, 4.15%)</title><rect x="47.8536%" y="421" width="4.1537%" height="15" fill="rgb(225,42,16)" fg:x="18583" fg:w="1613"/><text x="48.1036%" y="431.50">std::..</text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (265 samples, 0.68%)</title><rect x="51.3249%" y="405" width="0.6824%" height="15" fill="rgb(220,201,45)" fg:x="19931" fg:w="265"/><text x="51.5749%" y="415.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::spin_light (25 samples, 0.06%)</title><rect x="51.9429%" y="389" width="0.0644%" height="15" fill="rgb(225,33,4)" fg:x="20171" fg:w="25"/><text x="52.1929%" y="399.50"></text></g><g><title>core::hint::spin_loop (25 samples, 0.06%)</title><rect x="51.9429%" y="373" width="0.0644%" height="15" fill="rgb(224,33,50)" fg:x="20171" fg:w="25"/><text x="52.1929%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_pause (25 samples, 0.06%)</title><rect x="51.9429%" y="357" width="0.0644%" height="15" fill="rgb(246,198,51)" fg:x="20171" fg:w="25"/><text x="52.1929%" y="367.50"></text></g><g><title>core::mem::drop (16 samples, 0.04%)</title><rect x="52.0150%" y="453" width="0.0412%" height="15" fill="rgb(205,22,4)" fg:x="20199" fg:w="16"/><text x="52.2650%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (16 samples, 0.04%)</title><rect x="52.0150%" y="437" width="0.0412%" height="15" fill="rgb(206,3,8)" fg:x="20199" fg:w="16"/><text x="52.2650%" y="447.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (16 samples, 0.04%)</title><rect x="52.0150%" y="421" width="0.0412%" height="15" fill="rgb(251,23,15)" fg:x="20199" fg:w="16"/><text x="52.2650%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (16 samples, 0.04%)</title><rect x="52.0150%" y="405" width="0.0412%" height="15" fill="rgb(252,88,28)" fg:x="20199" fg:w="16"/><text x="52.2650%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (15 samples, 0.04%)</title><rect x="52.0176%" y="389" width="0.0386%" height="15" fill="rgb(212,127,14)" fg:x="20200" fg:w="15"/><text x="52.2676%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_sub (15 samples, 0.04%)</title><rect x="52.0176%" y="373" width="0.0386%" height="15" fill="rgb(247,145,37)" fg:x="20200" fg:w="15"/><text x="52.2676%" y="383.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (6 samples, 0.02%)</title><rect x="52.0562%" y="453" width="0.0155%" height="15" fill="rgb(209,117,53)" fg:x="20215" fg:w="6"/><text x="52.3062%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (6 samples, 0.02%)</title><rect x="52.0562%" y="437" width="0.0155%" height="15" fill="rgb(212,90,42)" fg:x="20215" fg:w="6"/><text x="52.3062%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (4 samples, 0.01%)</title><rect x="52.0768%" y="453" width="0.0103%" height="15" fill="rgb(218,164,37)" fg:x="20223" fg:w="4"/><text x="52.3268%" y="463.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (4 samples, 0.01%)</title><rect x="52.0768%" y="437" width="0.0103%" height="15" fill="rgb(246,65,34)" fg:x="20223" fg:w="4"/><text x="52.3268%" y="447.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (23 samples, 0.06%)</title><rect x="52.0871%" y="453" width="0.0592%" height="15" fill="rgb(231,100,33)" fg:x="20227" fg:w="23"/><text x="52.3371%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (23 samples, 0.06%)</title><rect x="52.0871%" y="437" width="0.0592%" height="15" fill="rgb(228,126,14)" fg:x="20227" fg:w="23"/><text x="52.3371%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (21 samples, 0.05%)</title><rect x="52.0923%" y="421" width="0.0541%" height="15" fill="rgb(215,173,21)" fg:x="20229" fg:w="21"/><text x="52.3423%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (21 samples, 0.05%)</title><rect x="52.0923%" y="405" width="0.0541%" height="15" fill="rgb(210,6,40)" fg:x="20229" fg:w="21"/><text x="52.3423%" y="415.50"></text></g><g><title>benchmark::alice_main (18,418 samples, 47.43%)</title><rect x="4.7640%" y="501" width="47.4287%" height="15" fill="rgb(212,48,18)" fg:x="1850" fg:w="18418"/><text x="5.0140%" y="511.50">benchmark::alice_main</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::send (8,789 samples, 22.63%)</title><rect x="29.5599%" y="485" width="22.6328%" height="15" fill="rgb(230,214,11)" fg:x="11479" fg:w="8789"/><text x="29.8099%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::send</text></g><g><title>zssp::zeta::send_payload (8,789 samples, 22.63%)</title><rect x="29.5599%" y="469" width="22.6328%" height="15" fill="rgb(254,105,39)" fg:x="11479" fg:w="8789"/><text x="29.8099%" y="479.50">zssp::zeta::send_payload</text></g><g><title>zssp::zeta::get_counter (18 samples, 0.05%)</title><rect x="52.1464%" y="453" width="0.0464%" height="15" fill="rgb(245,158,5)" fg:x="20250" fg:w="18"/><text x="52.3964%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_add (16 samples, 0.04%)</title><rect x="52.1515%" y="437" width="0.0412%" height="15" fill="rgb(249,208,11)" fg:x="20252" fg:w="16"/><text x="52.4015%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_add (16 samples, 0.04%)</title><rect x="52.1515%" y="421" width="0.0412%" height="15" fill="rgb(210,39,28)" fg:x="20252" fg:w="16"/><text x="52.4015%" y="431.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="52.2648%" y="485" width="0.0386%" height="15" fill="rgb(211,56,53)" fg:x="20296" fg:w="15"/><text x="52.5148%" y="495.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (15 samples, 0.04%)</title><rect x="52.3112%" y="485" width="0.0386%" height="15" fill="rgb(226,201,30)" fg:x="20314" fg:w="15"/><text x="52.5612%" y="495.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (15 samples, 0.04%)</title><rect x="52.3112%" y="469" width="0.0386%" height="15" fill="rgb(239,101,34)" fg:x="20314" fg:w="15"/><text x="52.5612%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (14 samples, 0.04%)</title><rect x="52.3138%" y="453" width="0.0361%" height="15" fill="rgb(226,209,5)" fg:x="20315" fg:w="14"/><text x="52.5638%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_sub (14 samples, 0.04%)</title><rect x="52.3138%" y="437" width="0.0361%" height="15" fill="rgb(250,105,47)" fg:x="20315" fg:w="14"/><text x="52.5638%" y="447.50"></text></g><g><title>core::time::Duration::as_millis (8 samples, 0.02%)</title><rect x="52.3498%" y="485" width="0.0206%" height="15" fill="rgb(230,72,3)" fg:x="20329" fg:w="8"/><text x="52.5998%" y="495.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map_err (4 samples, 0.01%)</title><rect x="52.4580%" y="421" width="0.0103%" height="15" fill="rgb(232,218,39)" fg:x="20371" fg:w="4"/><text x="52.7080%" y="431.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (7 samples, 0.02%)</title><rect x="52.4683%" y="421" width="0.0180%" height="15" fill="rgb(248,166,6)" fg:x="20375" fg:w="7"/><text x="52.7183%" y="431.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (6 samples, 0.02%)</title><rect x="52.4708%" y="405" width="0.0155%" height="15" fill="rgb(247,89,20)" fg:x="20376" fg:w="6"/><text x="52.7208%" y="415.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::get_unchecked (6 samples, 0.02%)</title><rect x="52.5893%" y="405" width="0.0155%" height="15" fill="rgb(248,130,54)" fg:x="20422" fg:w="6"/><text x="52.8393%" y="415.50"></text></g><g><title>&lt;usize as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (6 samples, 0.02%)</title><rect x="52.5893%" y="389" width="0.0155%" height="15" fill="rgb(234,196,4)" fg:x="20422" fg:w="6"/><text x="52.8393%" y="399.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::add (6 samples, 0.02%)</title><rect x="52.5893%" y="373" width="0.0155%" height="15" fill="rgb(250,143,31)" fg:x="20422" fg:w="6"/><text x="52.8393%" y="383.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::offset (6 samples, 0.02%)</title><rect x="52.5893%" y="357" width="0.0155%" height="15" fill="rgb(211,110,34)" fg:x="20422" fg:w="6"/><text x="52.8393%" y="367.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (90 samples, 0.23%)</title><rect x="52.6047%" y="405" width="0.2318%" height="15" fill="rgb(215,124,48)" fg:x="20428" fg:w="90"/><text x="52.8547%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (90 samples, 0.23%)</title><rect x="52.6047%" y="389" width="0.2318%" height="15" fill="rgb(216,46,13)" fg:x="20428" fg:w="90"/><text x="52.8547%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (63 samples, 0.16%)</title><rect x="52.8365%" y="405" width="0.1622%" height="15" fill="rgb(205,184,25)" fg:x="20518" fg:w="63"/><text x="53.0865%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (63 samples, 0.16%)</title><rect x="52.8365%" y="389" width="0.1622%" height="15" fill="rgb(228,1,10)" fg:x="20518" fg:w="63"/><text x="53.0865%" y="399.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (200 samples, 0.52%)</title><rect x="52.4863%" y="421" width="0.5150%" height="15" fill="rgb(213,116,27)" fg:x="20382" fg:w="200"/><text x="52.7363%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (5 samples, 0.01%)</title><rect x="53.0142%" y="325" width="0.0129%" height="15" fill="rgb(241,95,50)" fg:x="20587" fg:w="5"/><text x="53.2642%" y="335.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="53.0142%" y="309" width="0.0129%" height="15" fill="rgb(238,48,32)" fg:x="20587" fg:w="5"/><text x="53.2642%" y="319.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (4 samples, 0.01%)</title><rect x="53.0322%" y="293" width="0.0103%" height="15" fill="rgb(235,113,49)" fg:x="20594" fg:w="4"/><text x="53.2822%" y="303.50"></text></g><g><title>core::sync::atomic::atomic_swap (4 samples, 0.01%)</title><rect x="53.0322%" y="277" width="0.0103%" height="15" fill="rgb(205,127,43)" fg:x="20594" fg:w="4"/><text x="53.2822%" y="287.50"></text></g><g><title>core::option::Option&lt;T&gt;::and_then (7 samples, 0.02%)</title><rect x="53.0425%" y="277" width="0.0180%" height="15" fill="rgb(250,162,2)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wait::_{{closure}} (7 samples, 0.02%)</title><rect x="53.0425%" y="261" width="0.0180%" height="15" fill="rgb(220,13,41)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="271.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (7 samples, 0.02%)</title><rect x="53.0425%" y="245" width="0.0180%" height="15" fill="rgb(249,221,25)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="255.50"></text></g><g><title>clock_gettime (7 samples, 0.02%)</title><rect x="53.0425%" y="229" width="0.0180%" height="15" fill="rgb(215,208,19)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="239.50"></text></g><g><title>[[vdso]] (7 samples, 0.02%)</title><rect x="53.0425%" y="213" width="0.0180%" height="15" fill="rgb(236,175,2)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="223.50"></text></g><g><title>[[vdso]] (4 samples, 0.01%)</title><rect x="53.0502%" y="197" width="0.0103%" height="15" fill="rgb(241,52,2)" fg:x="20601" fg:w="4"/><text x="53.3002%" y="207.50"></text></g><g><title>futex_unqueue (7 samples, 0.02%)</title><rect x="53.1095%" y="181" width="0.0180%" height="15" fill="rgb(248,140,14)" fg:x="20624" fg:w="7"/><text x="53.3595%" y="191.50"></text></g><g><title>enqueue_hrtimer (5 samples, 0.01%)</title><rect x="53.1352%" y="117" width="0.0129%" height="15" fill="rgb(253,22,42)" fg:x="20634" fg:w="5"/><text x="53.3852%" y="127.50"></text></g><g><title>hrtimer_sleeper_start_expires (6 samples, 0.02%)</title><rect x="53.1352%" y="165" width="0.0155%" height="15" fill="rgb(234,61,47)" fg:x="20634" fg:w="6"/><text x="53.3852%" y="175.50"></text></g><g><title>hrtimer_start_range_ns (6 samples, 0.02%)</title><rect x="53.1352%" y="149" width="0.0155%" height="15" fill="rgb(208,226,15)" fg:x="20634" fg:w="6"/><text x="53.3852%" y="159.50"></text></g><g><title>__hrtimer_start_range_ns (6 samples, 0.02%)</title><rect x="53.1352%" y="133" width="0.0155%" height="15" fill="rgb(217,221,4)" fg:x="20634" fg:w="6"/><text x="53.3852%" y="143.50"></text></g><g><title>update_curr (5 samples, 0.01%)</title><rect x="53.1944%" y="85" width="0.0129%" height="15" fill="rgb(212,174,34)" fg:x="20657" fg:w="5"/><text x="53.4444%" y="95.50"></text></g><g><title>dequeue_task (14 samples, 0.04%)</title><rect x="53.1841%" y="133" width="0.0361%" height="15" fill="rgb(253,83,4)" fg:x="20653" fg:w="14"/><text x="53.4341%" y="143.50"></text></g><g><title>dequeue_task_fair (14 samples, 0.04%)</title><rect x="53.1841%" y="117" width="0.0361%" height="15" fill="rgb(250,195,49)" fg:x="20653" fg:w="14"/><text x="53.4341%" y="127.50"></text></g><g><title>dequeue_entity (14 samples, 0.04%)</title><rect x="53.1841%" y="101" width="0.0361%" height="15" fill="rgb(241,192,25)" fg:x="20653" fg:w="14"/><text x="53.4341%" y="111.50"></text></g><g><title>update_load_avg (5 samples, 0.01%)</title><rect x="53.2073%" y="85" width="0.0129%" height="15" fill="rgb(208,124,10)" fg:x="20662" fg:w="5"/><text x="53.4573%" y="95.50"></text></g><g><title>__perf_event_task_sched_in (11 samples, 0.03%)</title><rect x="53.2202%" y="117" width="0.0283%" height="15" fill="rgb(222,33,0)" fg:x="20667" fg:w="11"/><text x="53.4702%" y="127.50"></text></g><g><title>perf_ctx_enable (11 samples, 0.03%)</title><rect x="53.2202%" y="101" width="0.0283%" height="15" fill="rgb(234,209,28)" fg:x="20667" fg:w="11"/><text x="53.4702%" y="111.50"></text></g><g><title>finish_task_switch.isra.0 (16 samples, 0.04%)</title><rect x="53.2202%" y="133" width="0.0412%" height="15" fill="rgb(224,11,23)" fg:x="20667" fg:w="16"/><text x="53.4702%" y="143.50"></text></g><g><title>raw_spin_rq_unlock (4 samples, 0.01%)</title><rect x="53.2511%" y="117" width="0.0103%" height="15" fill="rgb(232,99,1)" fg:x="20679" fg:w="4"/><text x="53.5011%" y="127.50"></text></g><g><title>pick_next_task (4 samples, 0.01%)</title><rect x="53.2614%" y="133" width="0.0103%" height="15" fill="rgb(237,95,45)" fg:x="20683" fg:w="4"/><text x="53.5114%" y="143.50"></text></g><g><title>prepare_task_switch (4 samples, 0.01%)</title><rect x="53.2717%" y="133" width="0.0103%" height="15" fill="rgb(208,109,11)" fg:x="20687" fg:w="4"/><text x="53.5217%" y="143.50"></text></g><g><title>psi_group_change (8 samples, 0.02%)</title><rect x="53.2923%" y="117" width="0.0206%" height="15" fill="rgb(216,190,48)" fg:x="20695" fg:w="8"/><text x="53.5423%" y="127.50"></text></g><g><title>psi_task_switch (13 samples, 0.03%)</title><rect x="53.2846%" y="133" width="0.0335%" height="15" fill="rgb(251,171,36)" fg:x="20692" fg:w="13"/><text x="53.5346%" y="143.50"></text></g><g><title>futex_wait_queue (78 samples, 0.20%)</title><rect x="53.1275%" y="181" width="0.2009%" height="15" fill="rgb(230,62,22)" fg:x="20631" fg:w="78"/><text x="53.3775%" y="191.50"></text></g><g><title>schedule (68 samples, 0.18%)</title><rect x="53.1532%" y="165" width="0.1751%" height="15" fill="rgb(225,114,35)" fg:x="20641" fg:w="68"/><text x="53.4032%" y="175.50"></text></g><g><title>__schedule (66 samples, 0.17%)</title><rect x="53.1584%" y="149" width="0.1700%" height="15" fill="rgb(215,118,42)" fg:x="20643" fg:w="66"/><text x="53.4084%" y="159.50"></text></g><g><title>__get_user_nocheck_4 (4 samples, 0.01%)</title><rect x="53.3309%" y="165" width="0.0103%" height="15" fill="rgb(243,119,21)" fg:x="20710" fg:w="4"/><text x="53.5809%" y="175.50"></text></g><g><title>futex_q_lock (10 samples, 0.03%)</title><rect x="53.3464%" y="165" width="0.0258%" height="15" fill="rgb(252,177,53)" fg:x="20716" fg:w="10"/><text x="53.5964%" y="175.50"></text></g><g><title>futex_wait_setup (18 samples, 0.05%)</title><rect x="53.3284%" y="181" width="0.0464%" height="15" fill="rgb(237,209,29)" fg:x="20709" fg:w="18"/><text x="53.5784%" y="191.50"></text></g><g><title>hrtimer_cancel (7 samples, 0.02%)</title><rect x="53.3747%" y="181" width="0.0180%" height="15" fill="rgb(212,65,23)" fg:x="20727" fg:w="7"/><text x="53.6247%" y="191.50"></text></g><g><title>hrtimer_try_to_cancel (6 samples, 0.02%)</title><rect x="53.3773%" y="165" width="0.0155%" height="15" fill="rgb(230,222,46)" fg:x="20728" fg:w="6"/><text x="53.6273%" y="175.50"></text></g><g><title>futex_wait (117 samples, 0.30%)</title><rect x="53.0940%" y="197" width="0.3013%" height="15" fill="rgb(215,135,32)" fg:x="20618" fg:w="117"/><text x="53.3440%" y="207.50"></text></g><g><title>do_futex (120 samples, 0.31%)</title><rect x="53.0889%" y="213" width="0.3090%" height="15" fill="rgb(246,101,22)" fg:x="20616" fg:w="120"/><text x="53.3389%" y="223.50"></text></g><g><title>__x64_sys_futex (130 samples, 0.33%)</title><rect x="53.0734%" y="229" width="0.3348%" height="15" fill="rgb(206,107,13)" fg:x="20610" fg:w="130"/><text x="53.3234%" y="239.50"></text></g><g><title>get_timespec64 (4 samples, 0.01%)</title><rect x="53.3979%" y="213" width="0.0103%" height="15" fill="rgb(250,100,44)" fg:x="20736" fg:w="4"/><text x="53.6479%" y="223.50"></text></g><g><title>_copy_from_user (4 samples, 0.01%)</title><rect x="53.3979%" y="197" width="0.0103%" height="15" fill="rgb(231,147,38)" fg:x="20736" fg:w="4"/><text x="53.6479%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (8 samples, 0.02%)</title><rect x="53.4108%" y="213" width="0.0206%" height="15" fill="rgb(229,8,40)" fg:x="20741" fg:w="8"/><text x="53.6608%" y="223.50"></text></g><g><title>exit_to_user_mode_loop (8 samples, 0.02%)</title><rect x="53.4108%" y="197" width="0.0206%" height="15" fill="rgb(221,135,30)" fg:x="20741" fg:w="8"/><text x="53.6608%" y="207.50"></text></g><g><title>__rseq_handle_notify_resume (5 samples, 0.01%)</title><rect x="53.4185%" y="181" width="0.0129%" height="15" fill="rgb(249,193,18)" fg:x="20744" fg:w="5"/><text x="53.6685%" y="191.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::park_timeout (157 samples, 0.40%)</title><rect x="53.0296%" y="309" width="0.4043%" height="15" fill="rgb(209,133,39)" fg:x="20593" fg:w="157"/><text x="53.2796%" y="319.50"></text></g><g><title>std::sys::unix::futex::futex_wait (152 samples, 0.39%)</title><rect x="53.0425%" y="293" width="0.3914%" height="15" fill="rgb(232,100,14)" fg:x="20598" fg:w="152"/><text x="53.2925%" y="303.50"></text></g><g><title>syscall (145 samples, 0.37%)</title><rect x="53.0605%" y="277" width="0.3734%" height="15" fill="rgb(224,185,1)" fg:x="20605" fg:w="145"/><text x="53.3105%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (140 samples, 0.36%)</title><rect x="53.0734%" y="261" width="0.3605%" height="15" fill="rgb(223,139,8)" fg:x="20610" fg:w="140"/><text x="53.3234%" y="271.50"></text></g><g><title>do_syscall_64 (140 samples, 0.36%)</title><rect x="53.0734%" y="245" width="0.3605%" height="15" fill="rgb(232,213,38)" fg:x="20610" fg:w="140"/><text x="53.3234%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (9 samples, 0.02%)</title><rect x="53.4108%" y="229" width="0.0232%" height="15" fill="rgb(207,94,22)" fg:x="20741" fg:w="9"/><text x="53.6608%" y="239.50"></text></g><g><title>std::thread::park_timeout (159 samples, 0.41%)</title><rect x="53.0296%" y="325" width="0.4094%" height="15" fill="rgb(219,183,54)" fg:x="20593" fg:w="159"/><text x="53.2796%" y="335.50"></text></g><g><title>std::sync::mpmc::context::Context::wait_until (168 samples, 0.43%)</title><rect x="53.0090%" y="341" width="0.4326%" height="15" fill="rgb(216,185,54)" fg:x="20585" fg:w="168"/><text x="53.2590%" y="351.50"></text></g><g><title>core::sync::atomic::AtomicBool::store (6 samples, 0.02%)</title><rect x="53.4468%" y="325" width="0.0155%" height="15" fill="rgb(254,217,39)" fg:x="20755" fg:w="6"/><text x="53.6968%" y="335.50"></text></g><g><title>core::sync::atomic::atomic_store (6 samples, 0.02%)</title><rect x="53.4468%" y="309" width="0.0155%" height="15" fill="rgb(240,178,23)" fg:x="20755" fg:w="6"/><text x="53.6968%" y="319.50"></text></g><g><title>std::sync::mpmc::context::Context::with (187 samples, 0.48%)</title><rect x="53.0013%" y="421" width="0.4815%" height="15" fill="rgb(218,11,47)" fg:x="20582" fg:w="187"/><text x="53.2513%" y="431.50"></text></g><g><title>std::thread::local::LocalKey&lt;T&gt;::try_with (187 samples, 0.48%)</title><rect x="53.0013%" y="405" width="0.4815%" height="15" fill="rgb(218,51,51)" fg:x="20582" fg:w="187"/><text x="53.2513%" y="415.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (187 samples, 0.48%)</title><rect x="53.0013%" y="389" width="0.4815%" height="15" fill="rgb(238,126,27)" fg:x="20582" fg:w="187"/><text x="53.2513%" y="399.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (187 samples, 0.48%)</title><rect x="53.0013%" y="373" width="0.4815%" height="15" fill="rgb(249,202,22)" fg:x="20582" fg:w="187"/><text x="53.2513%" y="383.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv::_{{closure}} (185 samples, 0.48%)</title><rect x="53.0065%" y="357" width="0.4764%" height="15" fill="rgb(254,195,49)" fg:x="20584" fg:w="185"/><text x="53.2565%" y="367.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::register (15 samples, 0.04%)</title><rect x="53.4442%" y="341" width="0.0386%" height="15" fill="rgb(208,123,14)" fg:x="20754" fg:w="15"/><text x="53.6942%" y="351.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (6 samples, 0.02%)</title><rect x="53.4674%" y="325" width="0.0155%" height="15" fill="rgb(224,200,8)" fg:x="20763" fg:w="6"/><text x="53.7174%" y="335.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (6 samples, 0.02%)</title><rect x="53.4674%" y="309" width="0.0155%" height="15" fill="rgb(217,61,36)" fg:x="20763" fg:w="6"/><text x="53.7174%" y="319.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (6 samples, 0.02%)</title><rect x="53.4674%" y="293" width="0.0155%" height="15" fill="rgb(206,35,45)" fg:x="20763" fg:w="6"/><text x="53.7174%" y="303.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (6 samples, 0.02%)</title><rect x="53.4674%" y="277" width="0.0155%" height="15" fill="rgb(217,65,33)" fg:x="20763" fg:w="6"/><text x="53.7174%" y="287.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (4 samples, 0.01%)</title><rect x="53.4829%" y="421" width="0.0103%" height="15" fill="rgb(222,158,48)" fg:x="20769" fg:w="4"/><text x="53.7329%" y="431.50"></text></g><g><title>clock_gettime (4 samples, 0.01%)</title><rect x="53.4829%" y="405" width="0.0103%" height="15" fill="rgb(254,2,54)" fg:x="20769" fg:w="4"/><text x="53.7329%" y="415.50"></text></g><g><title>[[vdso]] (4 samples, 0.01%)</title><rect x="53.4829%" y="389" width="0.0103%" height="15" fill="rgb(250,143,38)" fg:x="20769" fg:w="4"/><text x="53.7329%" y="399.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_deadline (418 samples, 1.08%)</title><rect x="52.4193%" y="453" width="1.0764%" height="15" fill="rgb(248,25,0)" fg:x="20356" fg:w="418"/><text x="52.6693%" y="463.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv (416 samples, 1.07%)</title><rect x="52.4245%" y="437" width="1.0713%" height="15" fill="rgb(206,152,27)" fg:x="20358" fg:w="416"/><text x="52.6745%" y="447.50"></text></g><g><title>[[vdso]] (164 samples, 0.42%)</title><rect x="53.5138%" y="421" width="0.4223%" height="15" fill="rgb(240,77,30)" fg:x="20781" fg:w="164"/><text x="53.7638%" y="431.50"></text></g><g><title>[[vdso]] (114 samples, 0.29%)</title><rect x="53.6425%" y="405" width="0.2936%" height="15" fill="rgb(231,5,3)" fg:x="20831" fg:w="114"/><text x="53.8925%" y="415.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (175 samples, 0.45%)</title><rect x="53.5009%" y="453" width="0.4506%" height="15" fill="rgb(207,226,32)" fg:x="20776" fg:w="175"/><text x="53.7509%" y="463.50"></text></g><g><title>clock_gettime (173 samples, 0.45%)</title><rect x="53.5060%" y="437" width="0.4455%" height="15" fill="rgb(222,207,47)" fg:x="20778" fg:w="173"/><text x="53.7560%" y="447.50"></text></g><g><title>__vdso_clock_gettime (6 samples, 0.02%)</title><rect x="53.9361%" y="421" width="0.0155%" height="15" fill="rgb(229,115,45)" fg:x="20945" fg:w="6"/><text x="54.1861%" y="431.50"></text></g><g><title>std::sync::mpsc::Receiver&lt;T&gt;::recv_timeout (634 samples, 1.63%)</title><rect x="52.3704%" y="485" width="1.6326%" height="15" fill="rgb(224,191,6)" fg:x="20337" fg:w="634"/><text x="52.6204%" y="495.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (628 samples, 1.62%)</title><rect x="52.3859%" y="469" width="1.6172%" height="15" fill="rgb(230,227,24)" fg:x="20343" fg:w="628"/><text x="52.6359%" y="479.50"></text></g><g><title>std::time::SystemTime::checked_add (17 samples, 0.04%)</title><rect x="53.9593%" y="453" width="0.0438%" height="15" fill="rgb(228,80,19)" fg:x="20954" fg:w="17"/><text x="54.2093%" y="463.50"></text></g><g><title>std::sys::unix::time::SystemTime::checked_add_duration (16 samples, 0.04%)</title><rect x="53.9618%" y="437" width="0.0412%" height="15" fill="rgb(247,229,0)" fg:x="20955" fg:w="16"/><text x="54.2118%" y="447.50"></text></g><g><title>std::sys::unix::time::Timespec::checked_add_duration (16 samples, 0.04%)</title><rect x="53.9618%" y="421" width="0.0412%" height="15" fill="rgb(237,194,15)" fg:x="20955" fg:w="16"/><text x="54.2118%" y="431.50"></text></g><g><title>core::option::Option&lt;T&gt;::and_then (8 samples, 0.02%)</title><rect x="53.9824%" y="405" width="0.0206%" height="15" fill="rgb(219,203,20)" fg:x="20963" fg:w="8"/><text x="54.2324%" y="415.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="54.0957%" y="341" width="0.0129%" height="15" fill="rgb(234,128,8)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="54.0957%" y="325" width="0.0129%" height="15" fill="rgb(248,202,8)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="335.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="54.0957%" y="309" width="0.0129%" height="15" fill="rgb(206,104,37)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="54.0957%" y="293" width="0.0129%" height="15" fill="rgb(223,8,27)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="54.0957%" y="277" width="0.0129%" height="15" fill="rgb(216,217,28)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="54.0957%" y="261" width="0.0129%" height="15" fill="rgb(249,199,1)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="54.0957%" y="245" width="0.0129%" height="15" fill="rgb(240,85,17)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="54.0957%" y="229" width="0.0129%" height="15" fill="rgb(206,108,45)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="239.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="54.0957%" y="213" width="0.0129%" height="15" fill="rgb(245,210,41)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="54.0957%" y="197" width="0.0129%" height="15" fill="rgb(206,13,37)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="207.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="54.0957%" y="181" width="0.0129%" height="15" fill="rgb(250,61,18)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="191.50"></text></g><g><title>core::cmp::impls::&lt;impl core::cmp::PartialOrd&lt;&amp;B&gt; for &amp;A&gt;::ge (21 samples, 0.05%)</title><rect x="54.0571%" y="389" width="0.0541%" height="15" fill="rgb(235,172,48)" fg:x="20992" fg:w="21"/><text x="54.3071%" y="399.50"></text></g><g><title>core::cmp::PartialOrd::ge (21 samples, 0.05%)</title><rect x="54.0571%" y="373" width="0.0541%" height="15" fill="rgb(249,201,17)" fg:x="20992" fg:w="21"/><text x="54.3071%" y="383.50"></text></g><g><title>&lt;std::sys::unix::time::Timespec as core::cmp::PartialOrd&gt;::partial_cmp (15 samples, 0.04%)</title><rect x="54.0726%" y="357" width="0.0386%" height="15" fill="rgb(219,208,6)" fg:x="20998" fg:w="15"/><text x="54.3226%" y="367.50"></text></g><g><title>std::time::Instant::duration_since (45 samples, 0.12%)</title><rect x="54.0082%" y="453" width="0.1159%" height="15" fill="rgb(248,31,23)" fg:x="20973" fg:w="45"/><text x="54.2582%" y="463.50"></text></g><g><title>std::time::Instant::checked_duration_since (45 samples, 0.12%)</title><rect x="54.0082%" y="437" width="0.1159%" height="15" fill="rgb(245,15,42)" fg:x="20973" fg:w="45"/><text x="54.2582%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (45 samples, 0.12%)</title><rect x="54.0082%" y="421" width="0.1159%" height="15" fill="rgb(222,217,39)" fg:x="20973" fg:w="45"/><text x="54.2582%" y="431.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (45 samples, 0.12%)</title><rect x="54.0082%" y="405" width="0.1159%" height="15" fill="rgb(210,219,27)" fg:x="20973" fg:w="45"/><text x="54.2582%" y="415.50"></text></g><g><title>core::time::Duration::new (5 samples, 0.01%)</title><rect x="54.1112%" y="389" width="0.0129%" height="15" fill="rgb(252,166,36)" fg:x="21013" fg:w="5"/><text x="54.3612%" y="399.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (48 samples, 0.12%)</title><rect x="54.0082%" y="469" width="0.1236%" height="15" fill="rgb(245,132,34)" fg:x="20973" fg:w="48"/><text x="54.2582%" y="479.50"></text></g><g><title>[[vdso]] (111 samples, 0.29%)</title><rect x="54.2297%" y="389" width="0.2858%" height="15" fill="rgb(236,54,3)" fg:x="21059" fg:w="111"/><text x="54.4797%" y="399.50"></text></g><g><title>[[vdso]] (145 samples, 0.37%)</title><rect x="54.1550%" y="405" width="0.3734%" height="15" fill="rgb(241,173,43)" fg:x="21030" fg:w="145"/><text x="54.4050%" y="415.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="54.5155%" y="389" width="0.0129%" height="15" fill="rgb(215,190,9)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="399.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="54.5155%" y="373" width="0.0129%" height="15" fill="rgb(242,101,16)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="383.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="54.5155%" y="357" width="0.0129%" height="15" fill="rgb(223,190,21)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="367.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="54.5155%" y="341" width="0.0129%" height="15" fill="rgb(215,228,25)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="351.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="54.5155%" y="325" width="0.0129%" height="15" fill="rgb(225,36,22)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="335.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="54.5155%" y="309" width="0.0129%" height="15" fill="rgb(251,106,46)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="319.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="54.5155%" y="293" width="0.0129%" height="15" fill="rgb(208,90,1)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="303.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="54.5155%" y="277" width="0.0129%" height="15" fill="rgb(243,10,4)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="287.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="54.5155%" y="261" width="0.0129%" height="15" fill="rgb(212,137,27)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="271.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="54.5181%" y="245" width="0.0103%" height="15" fill="rgb(231,220,49)" fg:x="21171" fg:w="4"/><text x="54.7681%" y="255.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="54.5181%" y="229" width="0.0103%" height="15" fill="rgb(237,96,20)" fg:x="21171" fg:w="4"/><text x="54.7681%" y="239.50"></text></g><g><title>std::time::Instant::elapsed (208 samples, 0.54%)</title><rect x="54.0030%" y="485" width="0.5356%" height="15" fill="rgb(239,229,30)" fg:x="20971" fg:w="208"/><text x="54.2530%" y="495.50"></text></g><g><title>std::time::Instant::now (158 samples, 0.41%)</title><rect x="54.1318%" y="469" width="0.4069%" height="15" fill="rgb(219,65,33)" fg:x="21021" fg:w="158"/><text x="54.3818%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::Instant::now (158 samples, 0.41%)</title><rect x="54.1318%" y="453" width="0.4069%" height="15" fill="rgb(243,134,7)" fg:x="21021" fg:w="158"/><text x="54.3818%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (155 samples, 0.40%)</title><rect x="54.1395%" y="437" width="0.3991%" height="15" fill="rgb(216,177,54)" fg:x="21024" fg:w="155"/><text x="54.3895%" y="447.50"></text></g><g><title>clock_gettime (151 samples, 0.39%)</title><rect x="54.1498%" y="421" width="0.3888%" height="15" fill="rgb(211,160,20)" fg:x="21028" fg:w="151"/><text x="54.3998%" y="431.50"></text></g><g><title>__vdso_clock_gettime (4 samples, 0.01%)</title><rect x="54.5284%" y="405" width="0.0103%" height="15" fill="rgb(239,85,39)" fg:x="21175" fg:w="4"/><text x="54.7784%" y="415.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (317 samples, 0.82%)</title><rect x="54.7138%" y="469" width="0.8163%" height="15" fill="rgb(232,125,22)" fg:x="21247" fg:w="317"/><text x="54.9638%" y="479.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (317 samples, 0.82%)</title><rect x="54.7138%" y="453" width="0.8163%" height="15" fill="rgb(244,57,34)" fg:x="21247" fg:w="317"/><text x="54.9638%" y="463.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (317 samples, 0.82%)</title><rect x="54.7138%" y="437" width="0.8163%" height="15" fill="rgb(214,203,32)" fg:x="21247" fg:w="317"/><text x="54.9638%" y="447.50"></text></g><g><title>&lt;core::result::Result&lt;T,E&gt; as core::ops::try_trait::Try&gt;::branch (6 samples, 0.02%)</title><rect x="55.5301%" y="469" width="0.0155%" height="15" fill="rgb(207,58,43)" fg:x="21564" fg:w="6"/><text x="55.7801%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (76 samples, 0.20%)</title><rect x="55.5533%" y="453" width="0.1957%" height="15" fill="rgb(215,193,15)" fg:x="21573" fg:w="76"/><text x="55.8033%" y="463.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (76 samples, 0.20%)</title><rect x="55.5533%" y="437" width="0.1957%" height="15" fill="rgb(232,15,44)" fg:x="21573" fg:w="76"/><text x="55.8033%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (75 samples, 0.19%)</title><rect x="55.5558%" y="421" width="0.1931%" height="15" fill="rgb(212,3,48)" fg:x="21574" fg:w="75"/><text x="55.8058%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (71 samples, 0.18%)</title><rect x="55.5661%" y="405" width="0.1828%" height="15" fill="rgb(218,128,7)" fg:x="21578" fg:w="71"/><text x="55.8161%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_swap (71 samples, 0.18%)</title><rect x="55.5661%" y="389" width="0.1828%" height="15" fill="rgb(226,216,39)" fg:x="21578" fg:w="71"/><text x="55.8161%" y="399.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (6 samples, 0.02%)</title><rect x="55.7490%" y="437" width="0.0155%" height="15" fill="rgb(243,47,51)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="447.50"></text></g><g><title>std::sync::poison::Flag::guard (6 samples, 0.02%)</title><rect x="55.7490%" y="421" width="0.0155%" height="15" fill="rgb(241,183,40)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="431.50"></text></g><g><title>std::thread::panicking (6 samples, 0.02%)</title><rect x="55.7490%" y="405" width="0.0155%" height="15" fill="rgb(231,217,32)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="415.50"></text></g><g><title>std::panicking::panicking (6 samples, 0.02%)</title><rect x="55.7490%" y="389" width="0.0155%" height="15" fill="rgb(229,61,38)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="399.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (6 samples, 0.02%)</title><rect x="55.7490%" y="373" width="0.0155%" height="15" fill="rgb(225,210,5)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (73 samples, 0.19%)</title><rect x="55.7490%" y="453" width="0.1880%" height="15" fill="rgb(231,79,45)" fg:x="21649" fg:w="73"/><text x="55.9990%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (67 samples, 0.17%)</title><rect x="55.7644%" y="437" width="0.1725%" height="15" fill="rgb(224,100,7)" fg:x="21655" fg:w="67"/><text x="56.0144%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (66 samples, 0.17%)</title><rect x="55.7670%" y="421" width="0.1700%" height="15" fill="rgb(241,198,18)" fg:x="21656" fg:w="66"/><text x="56.0170%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (66 samples, 0.17%)</title><rect x="55.7670%" y="405" width="0.1700%" height="15" fill="rgb(252,97,53)" fg:x="21656" fg:w="66"/><text x="56.0170%" y="415.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (355 samples, 0.91%)</title><rect x="55.5533%" y="469" width="0.9142%" height="15" fill="rgb(220,88,7)" fg:x="21573" fg:w="355"/><text x="55.8033%" y="479.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (206 samples, 0.53%)</title><rect x="55.9370%" y="453" width="0.5305%" height="15" fill="rgb(213,176,14)" fg:x="21722" fg:w="206"/><text x="56.1870%" y="463.50"></text></g><g><title>EVP_DecryptUpdate (202 samples, 0.52%)</title><rect x="55.9473%" y="437" width="0.5202%" height="15" fill="rgb(246,73,7)" fg:x="21726" fg:w="202"/><text x="56.1973%" y="447.50"></text></g><g><title>[libcrypto.so.3] (165 samples, 0.42%)</title><rect x="56.0425%" y="421" width="0.4249%" height="15" fill="rgb(245,64,36)" fg:x="21763" fg:w="165"/><text x="56.2925%" y="431.50"></text></g><g><title>[libcrypto.so.3] (125 samples, 0.32%)</title><rect x="56.1455%" y="405" width="0.3219%" height="15" fill="rgb(245,80,10)" fg:x="21803" fg:w="125"/><text x="56.3955%" y="415.50"></text></g><g><title>[libcrypto.so.3] (116 samples, 0.30%)</title><rect x="56.1687%" y="389" width="0.2987%" height="15" fill="rgb(232,107,50)" fg:x="21812" fg:w="116"/><text x="56.4187%" y="399.50"></text></g><g><title>__rust_probestack (6 samples, 0.02%)</title><rect x="56.4674%" y="469" width="0.0155%" height="15" fill="rgb(253,3,0)" fg:x="21928" fg:w="6"/><text x="56.7174%" y="479.50"></text></g><g><title>core::cmp::Ord::max (5 samples, 0.01%)</title><rect x="56.4829%" y="469" width="0.0129%" height="15" fill="rgb(212,99,53)" fg:x="21934" fg:w="5"/><text x="56.7329%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (5 samples, 0.01%)</title><rect x="56.4829%" y="453" width="0.0129%" height="15" fill="rgb(249,111,54)" fg:x="21934" fg:w="5"/><text x="56.7329%" y="463.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade::_{{closure}} (6 samples, 0.02%)</title><rect x="56.5189%" y="405" width="0.0155%" height="15" fill="rgb(249,55,30)" fg:x="21948" fg:w="6"/><text x="56.7689%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (73 samples, 0.19%)</title><rect x="56.5344%" y="405" width="0.1880%" height="15" fill="rgb(237,47,42)" fg:x="21954" fg:w="73"/><text x="56.7844%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (73 samples, 0.19%)</title><rect x="56.5344%" y="389" width="0.1880%" height="15" fill="rgb(211,20,18)" fg:x="21954" fg:w="73"/><text x="56.7844%" y="399.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade (92 samples, 0.24%)</title><rect x="56.5009%" y="437" width="0.2369%" height="15" fill="rgb(231,203,46)" fg:x="21941" fg:w="92"/><text x="56.7509%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_update (88 samples, 0.23%)</title><rect x="56.5112%" y="421" width="0.2266%" height="15" fill="rgb(237,142,3)" fg:x="21945" fg:w="88"/><text x="56.7612%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (6 samples, 0.02%)</title><rect x="56.7224%" y="405" width="0.0155%" height="15" fill="rgb(241,107,1)" fg:x="22027" fg:w="6"/><text x="56.9724%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="56.7224%" y="389" width="0.0155%" height="15" fill="rgb(229,83,13)" fg:x="22027" fg:w="6"/><text x="56.9724%" y="399.50"></text></g><g><title>core::option::Option&lt;T&gt;::map (99 samples, 0.25%)</title><rect x="56.5009%" y="469" width="0.2549%" height="15" fill="rgb(241,91,40)" fg:x="21941" fg:w="99"/><text x="56.7509%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive::_{{closure}} (99 samples, 0.25%)</title><rect x="56.5009%" y="453" width="0.2549%" height="15" fill="rgb(225,3,45)" fg:x="21941" fg:w="99"/><text x="56.7509%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (7 samples, 0.02%)</title><rect x="56.7378%" y="437" width="0.0180%" height="15" fill="rgb(244,223,14)" fg:x="22033" fg:w="7"/><text x="56.9878%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (45 samples, 0.12%)</title><rect x="56.7559%" y="469" width="0.1159%" height="15" fill="rgb(224,124,37)" fg:x="22040" fg:w="45"/><text x="57.0059%" y="479.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (45 samples, 0.12%)</title><rect x="56.7559%" y="453" width="0.1159%" height="15" fill="rgb(251,171,30)" fg:x="22040" fg:w="45"/><text x="57.0059%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (43 samples, 0.11%)</title><rect x="56.7610%" y="437" width="0.1107%" height="15" fill="rgb(236,46,54)" fg:x="22042" fg:w="43"/><text x="57.0110%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_sub (43 samples, 0.11%)</title><rect x="56.7610%" y="421" width="0.1107%" height="15" fill="rgb(245,213,5)" fg:x="22042" fg:w="43"/><text x="57.0110%" y="431.50"></text></g><g><title>__rdl_dealloc (4 samples, 0.01%)</title><rect x="56.8949%" y="293" width="0.0103%" height="15" fill="rgb(230,144,27)" fg:x="22094" fg:w="4"/><text x="57.1449%" y="303.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::dealloc (4 samples, 0.01%)</title><rect x="56.8949%" y="277" width="0.0103%" height="15" fill="rgb(220,86,6)" fg:x="22094" fg:w="4"/><text x="57.1449%" y="287.50"></text></g><g><title>__rust_dealloc (9 samples, 0.02%)</title><rect x="56.9052%" y="293" width="0.0232%" height="15" fill="rgb(240,20,13)" fg:x="22098" fg:w="9"/><text x="57.1552%" y="303.50"></text></g><g><title>[libc.so.6] (76 samples, 0.20%)</title><rect x="58.2494%" y="261" width="0.1957%" height="15" fill="rgb(217,89,34)" fg:x="22620" fg:w="76"/><text x="58.4994%" y="271.50"></text></g><g><title>__entry_text_start (13 samples, 0.03%)</title><rect x="58.5687%" y="245" width="0.0335%" height="15" fill="rgb(229,13,5)" fg:x="22744" fg:w="13"/><text x="58.8187%" y="255.50"></text></g><g><title>futex_unqueue (17 samples, 0.04%)</title><rect x="58.6640%" y="165" width="0.0438%" height="15" fill="rgb(244,67,35)" fg:x="22781" fg:w="17"/><text x="58.9140%" y="175.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="58.7876%" y="117" width="0.0103%" height="15" fill="rgb(221,40,2)" fg:x="22829" fg:w="4"/><text x="59.0376%" y="127.50"></text></g><g><title>cpuacct_charge (10 samples, 0.03%)</title><rect x="58.8520%" y="53" width="0.0258%" height="15" fill="rgb(237,157,21)" fg:x="22854" fg:w="10"/><text x="59.1020%" y="63.50"></text></g><g><title>update_curr (18 samples, 0.05%)</title><rect x="58.8340%" y="69" width="0.0464%" height="15" fill="rgb(222,94,11)" fg:x="22847" fg:w="18"/><text x="59.0840%" y="79.50"></text></g><g><title>dequeue_entity (32 samples, 0.08%)</title><rect x="58.8108%" y="85" width="0.0824%" height="15" fill="rgb(249,113,6)" fg:x="22838" fg:w="32"/><text x="59.0608%" y="95.50"></text></g><g><title>update_load_avg (5 samples, 0.01%)</title><rect x="58.8803%" y="69" width="0.0129%" height="15" fill="rgb(238,137,36)" fg:x="22865" fg:w="5"/><text x="59.1303%" y="79.50"></text></g><g><title>dequeue_task (42 samples, 0.11%)</title><rect x="58.7979%" y="117" width="0.1082%" height="15" fill="rgb(210,102,26)" fg:x="22833" fg:w="42"/><text x="59.0479%" y="127.50"></text></g><g><title>dequeue_task_fair (42 samples, 0.11%)</title><rect x="58.7979%" y="101" width="0.1082%" height="15" fill="rgb(218,30,30)" fg:x="22833" fg:w="42"/><text x="59.0479%" y="111.50"></text></g><g><title>__perf_event_task_sched_in (9 samples, 0.02%)</title><rect x="58.9267%" y="101" width="0.0232%" height="15" fill="rgb(214,67,26)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="111.50"></text></g><g><title>perf_ctx_enable (9 samples, 0.02%)</title><rect x="58.9267%" y="85" width="0.0232%" height="15" fill="rgb(251,9,53)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="95.50"></text></g><g><title>x86_pmu_enable (9 samples, 0.02%)</title><rect x="58.9267%" y="69" width="0.0232%" height="15" fill="rgb(228,204,25)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="79.50"></text></g><g><title>intel_pmu_enable_all (9 samples, 0.02%)</title><rect x="58.9267%" y="53" width="0.0232%" height="15" fill="rgb(207,153,8)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="63.50"></text></g><g><title>native_write_msr (9 samples, 0.02%)</title><rect x="58.9267%" y="37" width="0.0232%" height="15" fill="rgb(242,9,16)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="47.50"></text></g><g><title>finish_task_switch.isra.0 (29 samples, 0.07%)</title><rect x="58.9112%" y="117" width="0.0747%" height="15" fill="rgb(217,211,10)" fg:x="22877" fg:w="29"/><text x="59.1612%" y="127.50"></text></g><g><title>raw_spin_rq_unlock (12 samples, 0.03%)</title><rect x="58.9550%" y="101" width="0.0309%" height="15" fill="rgb(219,228,52)" fg:x="22894" fg:w="12"/><text x="59.2050%" y="111.50"></text></g><g><title>pick_next_task_fair (4 samples, 0.01%)</title><rect x="58.9859%" y="101" width="0.0103%" height="15" fill="rgb(231,92,29)" fg:x="22906" fg:w="4"/><text x="59.2359%" y="111.50"></text></g><g><title>pick_next_task (10 samples, 0.03%)</title><rect x="58.9859%" y="117" width="0.0258%" height="15" fill="rgb(232,8,23)" fg:x="22906" fg:w="10"/><text x="59.2359%" y="127.50"></text></g><g><title>put_prev_task_fair (6 samples, 0.02%)</title><rect x="58.9962%" y="101" width="0.0155%" height="15" fill="rgb(216,211,34)" fg:x="22910" fg:w="6"/><text x="59.2462%" y="111.50"></text></g><g><title>prepare_task_switch (15 samples, 0.04%)</title><rect x="59.0117%" y="117" width="0.0386%" height="15" fill="rgb(236,151,0)" fg:x="22916" fg:w="15"/><text x="59.2617%" y="127.50"></text></g><g><title>__perf_event_task_sched_out (6 samples, 0.02%)</title><rect x="59.0348%" y="101" width="0.0155%" height="15" fill="rgb(209,168,3)" fg:x="22925" fg:w="6"/><text x="59.2848%" y="111.50"></text></g><g><title>psi_group_change (38 samples, 0.10%)</title><rect x="59.0760%" y="101" width="0.0979%" height="15" fill="rgb(208,129,28)" fg:x="22941" fg:w="38"/><text x="59.3260%" y="111.50"></text></g><g><title>psi_task_switch (52 samples, 0.13%)</title><rect x="59.0554%" y="117" width="0.1339%" height="15" fill="rgb(229,78,22)" fg:x="22933" fg:w="52"/><text x="59.3054%" y="127.50"></text></g><g><title>__schedule (179 samples, 0.46%)</title><rect x="58.7516%" y="133" width="0.4609%" height="15" fill="rgb(228,187,13)" fg:x="22815" fg:w="179"/><text x="59.0016%" y="143.50"></text></g><g><title>update_rq_clock (5 samples, 0.01%)</title><rect x="59.1996%" y="117" width="0.0129%" height="15" fill="rgb(240,119,24)" fg:x="22989" fg:w="5"/><text x="59.4496%" y="127.50"></text></g><g><title>sched_clock_cpu (5 samples, 0.01%)</title><rect x="59.1996%" y="101" width="0.0129%" height="15" fill="rgb(209,194,42)" fg:x="22989" fg:w="5"/><text x="59.4496%" y="111.50"></text></g><g><title>sched_clock (4 samples, 0.01%)</title><rect x="59.2022%" y="85" width="0.0103%" height="15" fill="rgb(247,200,46)" fg:x="22990" fg:w="4"/><text x="59.4522%" y="95.50"></text></g><g><title>native_sched_clock (4 samples, 0.01%)</title><rect x="59.2022%" y="69" width="0.0103%" height="15" fill="rgb(218,76,16)" fg:x="22990" fg:w="4"/><text x="59.4522%" y="79.50"></text></g><g><title>futex_wait_queue (199 samples, 0.51%)</title><rect x="58.7078%" y="165" width="0.5125%" height="15" fill="rgb(225,21,48)" fg:x="22798" fg:w="199"/><text x="58.9578%" y="175.50"></text></g><g><title>schedule (187 samples, 0.48%)</title><rect x="58.7387%" y="149" width="0.4815%" height="15" fill="rgb(239,223,50)" fg:x="22810" fg:w="187"/><text x="58.9887%" y="159.50"></text></g><g><title>__get_user_nocheck_4 (26 samples, 0.07%)</title><rect x="59.2280%" y="149" width="0.0670%" height="15" fill="rgb(244,45,21)" fg:x="23000" fg:w="26"/><text x="59.4780%" y="159.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="59.2949%" y="149" width="0.0103%" height="15" fill="rgb(232,33,43)" fg:x="23026" fg:w="4"/><text x="59.5449%" y="159.50"></text></g><g><title>futex_hash (5 samples, 0.01%)</title><rect x="59.3078%" y="149" width="0.0129%" height="15" fill="rgb(209,8,3)" fg:x="23031" fg:w="5"/><text x="59.5578%" y="159.50"></text></g><g><title>futex_q_lock (5 samples, 0.01%)</title><rect x="59.3207%" y="149" width="0.0129%" height="15" fill="rgb(214,25,53)" fg:x="23036" fg:w="5"/><text x="59.5707%" y="159.50"></text></g><g><title>futex_q_unlock (5 samples, 0.01%)</title><rect x="59.3336%" y="149" width="0.0129%" height="15" fill="rgb(254,186,54)" fg:x="23041" fg:w="5"/><text x="59.5836%" y="159.50"></text></g><g><title>futex_wait (278 samples, 0.72%)</title><rect x="58.6383%" y="181" width="0.7159%" height="15" fill="rgb(208,174,49)" fg:x="22771" fg:w="278"/><text x="58.8883%" y="191.50"></text></g><g><title>futex_wait_setup (52 samples, 0.13%)</title><rect x="59.2203%" y="165" width="0.1339%" height="15" fill="rgb(233,191,51)" fg:x="22997" fg:w="52"/><text x="59.4703%" y="175.50"></text></g><g><title>do_futex (282 samples, 0.73%)</title><rect x="58.6305%" y="197" width="0.7262%" height="15" fill="rgb(222,134,10)" fg:x="22768" fg:w="282"/><text x="58.8805%" y="207.50"></text></g><g><title>__x64_sys_futex (292 samples, 0.75%)</title><rect x="58.6099%" y="213" width="0.7519%" height="15" fill="rgb(230,226,20)" fg:x="22760" fg:w="292"/><text x="58.8599%" y="223.50"></text></g><g><title>__get_user_8 (5 samples, 0.01%)</title><rect x="59.4263%" y="133" width="0.0129%" height="15" fill="rgb(251,111,25)" fg:x="23077" fg:w="5"/><text x="59.6763%" y="143.50"></text></g><g><title>rseq_ip_fixup (11 samples, 0.03%)</title><rect x="59.4134%" y="149" width="0.0283%" height="15" fill="rgb(224,40,46)" fg:x="23072" fg:w="11"/><text x="59.6634%" y="159.50"></text></g><g><title>exit_to_user_mode_loop (24 samples, 0.06%)</title><rect x="59.3851%" y="181" width="0.0618%" height="15" fill="rgb(236,108,47)" fg:x="23061" fg:w="24"/><text x="59.6351%" y="191.50"></text></g><g><title>__rseq_handle_notify_resume (15 samples, 0.04%)</title><rect x="59.4082%" y="165" width="0.0386%" height="15" fill="rgb(234,93,0)" fg:x="23070" fg:w="15"/><text x="59.6582%" y="175.50"></text></g><g><title>exit_to_user_mode_prepare (31 samples, 0.08%)</title><rect x="59.3748%" y="197" width="0.0798%" height="15" fill="rgb(224,213,32)" fg:x="23057" fg:w="31"/><text x="59.6248%" y="207.50"></text></g><g><title>do_syscall_64 (331 samples, 0.85%)</title><rect x="58.6074%" y="229" width="0.8524%" height="15" fill="rgb(251,11,48)" fg:x="22759" fg:w="331"/><text x="58.8574%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (36 samples, 0.09%)</title><rect x="59.3670%" y="213" width="0.0927%" height="15" fill="rgb(236,173,5)" fg:x="23054" fg:w="36"/><text x="59.6170%" y="223.50"></text></g><g><title>__lll_lock_wait_private (397 samples, 1.02%)</title><rect x="58.4451%" y="261" width="1.0223%" height="15" fill="rgb(230,95,12)" fg:x="22696" fg:w="397"/><text x="58.6951%" y="271.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (335 samples, 0.86%)</title><rect x="58.6048%" y="245" width="0.8627%" height="15" fill="rgb(232,209,1)" fg:x="22758" fg:w="335"/><text x="58.8548%" y="255.50"></text></g><g><title>[libc.so.6] (911 samples, 2.35%)</title><rect x="57.1241%" y="277" width="2.3459%" height="15" fill="rgb(232,6,1)" fg:x="22183" fg:w="911"/><text x="57.3741%" y="287.50">[..</text></g><g><title>__entry_text_start (15 samples, 0.04%)</title><rect x="59.4881%" y="261" width="0.0386%" height="15" fill="rgb(210,224,50)" fg:x="23101" fg:w="15"/><text x="59.7381%" y="271.50"></text></g><g><title>do_syscall_64 (4 samples, 0.01%)</title><rect x="59.5267%" y="261" width="0.0103%" height="15" fill="rgb(228,127,35)" fg:x="23116" fg:w="4"/><text x="59.7767%" y="271.50"></text></g><g><title>_raw_spin_lock (5 samples, 0.01%)</title><rect x="59.5679%" y="197" width="0.0129%" height="15" fill="rgb(245,102,45)" fg:x="23132" fg:w="5"/><text x="59.8179%" y="207.50"></text></g><g><title>futex_hash (8 samples, 0.02%)</title><rect x="59.5833%" y="197" width="0.0206%" height="15" fill="rgb(214,1,49)" fg:x="23138" fg:w="8"/><text x="59.8333%" y="207.50"></text></g><g><title>_raw_spin_lock (25 samples, 0.06%)</title><rect x="59.7147%" y="181" width="0.0644%" height="15" fill="rgb(226,163,40)" fg:x="23189" fg:w="25"/><text x="59.9647%" y="191.50"></text></g><g><title>native_queued_spin_lock_slowpath (25 samples, 0.06%)</title><rect x="59.7147%" y="165" width="0.0644%" height="15" fill="rgb(239,212,28)" fg:x="23189" fg:w="25"/><text x="59.9647%" y="175.50"></text></g><g><title>_raw_spin_unlock (4 samples, 0.01%)</title><rect x="59.7791%" y="181" width="0.0103%" height="15" fill="rgb(220,20,13)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="191.50"></text></g><g><title>preempt_schedule_thunk (4 samples, 0.01%)</title><rect x="59.7791%" y="165" width="0.0103%" height="15" fill="rgb(210,164,35)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="175.50"></text></g><g><title>preempt_schedule (4 samples, 0.01%)</title><rect x="59.7791%" y="149" width="0.0103%" height="15" fill="rgb(248,109,41)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="159.50"></text></g><g><title>__schedule (4 samples, 0.01%)</title><rect x="59.7791%" y="133" width="0.0103%" height="15" fill="rgb(238,23,50)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="59.7791%" y="117" width="0.0103%" height="15" fill="rgb(211,48,49)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="59.7791%" y="101" width="0.0103%" height="15" fill="rgb(223,36,21)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="111.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="59.7791%" y="85" width="0.0103%" height="15" fill="rgb(207,123,46)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="95.50"></text></g><g><title>futex_wake (77 samples, 0.20%)</title><rect x="59.6039%" y="197" width="0.1983%" height="15" fill="rgb(240,218,32)" fg:x="23146" fg:w="77"/><text x="59.8539%" y="207.50"></text></g><g><title>do_futex (97 samples, 0.25%)</title><rect x="59.5627%" y="213" width="0.2498%" height="15" fill="rgb(252,5,43)" fg:x="23130" fg:w="97"/><text x="59.8127%" y="223.50"></text></g><g><title>__x64_sys_futex (101 samples, 0.26%)</title><rect x="59.5550%" y="229" width="0.2601%" height="15" fill="rgb(252,84,19)" fg:x="23127" fg:w="101"/><text x="59.8050%" y="239.50"></text></g><g><title>do_syscall_64 (113 samples, 0.29%)</title><rect x="59.5499%" y="245" width="0.2910%" height="15" fill="rgb(243,152,39)" fg:x="23125" fg:w="113"/><text x="59.7999%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (6 samples, 0.02%)</title><rect x="59.8254%" y="229" width="0.0155%" height="15" fill="rgb(234,160,15)" fg:x="23232" fg:w="6"/><text x="60.0754%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="59.8280%" y="213" width="0.0129%" height="15" fill="rgb(237,34,20)" fg:x="23233" fg:w="5"/><text x="60.0780%" y="223.50"></text></g><g><title>alloc::alloc::dealloc (1,146 samples, 2.95%)</title><rect x="56.8949%" y="309" width="2.9511%" height="15" fill="rgb(229,97,13)" fg:x="22094" fg:w="1146"/><text x="57.1449%" y="319.50">all..</text></g><g><title>cfree (1,133 samples, 2.92%)</title><rect x="56.9284%" y="293" width="2.9176%" height="15" fill="rgb(234,71,50)" fg:x="22107" fg:w="1133"/><text x="57.1784%" y="303.50">cf..</text></g><g><title>__lll_lock_wake_private (146 samples, 0.38%)</title><rect x="59.4700%" y="277" width="0.3760%" height="15" fill="rgb(253,155,4)" fg:x="23094" fg:w="146"/><text x="59.7200%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (120 samples, 0.31%)</title><rect x="59.5370%" y="261" width="0.3090%" height="15" fill="rgb(222,185,37)" fg:x="23120" fg:w="120"/><text x="59.7870%" y="271.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (1,151 samples, 2.96%)</title><rect x="56.8949%" y="325" width="2.9640%" height="15" fill="rgb(251,177,13)" fg:x="22094" fg:w="1151"/><text x="57.1449%" y="335.50">&lt;al..</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (5 samples, 0.01%)</title><rect x="59.8460%" y="309" width="0.0129%" height="15" fill="rgb(250,179,40)" fg:x="23240" fg:w="5"/><text x="60.0960%" y="319.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (1,169 samples, 3.01%)</title><rect x="56.8717%" y="469" width="3.0103%" height="15" fill="rgb(242,44,2)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="479.50">cor..</text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (1,169 samples, 3.01%)</title><rect x="56.8717%" y="453" width="3.0103%" height="15" fill="rgb(216,177,13)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="463.50">&lt;ar..</text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (1,169 samples, 3.01%)</title><rect x="56.8717%" y="437" width="3.0103%" height="15" fill="rgb(216,106,43)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="447.50">arr..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (1,169 samples, 3.01%)</title><rect x="56.8717%" y="421" width="3.0103%" height="15" fill="rgb(216,183,2)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="431.50">arr..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (1,169 samples, 3.01%)</title><rect x="56.8717%" y="405" width="3.0103%" height="15" fill="rgb(249,75,3)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="415.50">arr..</text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (1,162 samples, 2.99%)</title><rect x="56.8898%" y="389" width="2.9923%" height="15" fill="rgb(219,67,39)" fg:x="22092" fg:w="1162"/><text x="57.1398%" y="399.50">cor..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (1,161 samples, 2.99%)</title><rect x="56.8923%" y="373" width="2.9897%" height="15" fill="rgb(253,228,2)" fg:x="22093" fg:w="1161"/><text x="57.1423%" y="383.50">cor..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (1,161 samples, 2.99%)</title><rect x="56.8923%" y="357" width="2.9897%" height="15" fill="rgb(235,138,27)" fg:x="22093" fg:w="1161"/><text x="57.1423%" y="367.50">cor..</text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (1,161 samples, 2.99%)</title><rect x="56.8923%" y="341" width="2.9897%" height="15" fill="rgb(236,97,51)" fg:x="22093" fg:w="1161"/><text x="57.1423%" y="351.50">&lt;al..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::current_memory (9 samples, 0.02%)</title><rect x="59.8589%" y="325" width="0.0232%" height="15" fill="rgb(240,80,30)" fg:x="23245" fg:w="9"/><text x="60.1089%" y="335.50"></text></g><g><title>std::sync::poison::Flag::done (4 samples, 0.01%)</title><rect x="59.8821%" y="437" width="0.0103%" height="15" fill="rgb(230,178,19)" fg:x="23254" fg:w="4"/><text x="60.1321%" y="447.50"></text></g><g><title>std::thread::panicking (4 samples, 0.01%)</title><rect x="59.8821%" y="421" width="0.0103%" height="15" fill="rgb(210,190,27)" fg:x="23254" fg:w="4"/><text x="60.1321%" y="431.50"></text></g><g><title>std::panicking::panicking (4 samples, 0.01%)</title><rect x="59.8821%" y="405" width="0.0103%" height="15" fill="rgb(222,107,31)" fg:x="23254" fg:w="4"/><text x="60.1321%" y="415.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (4 samples, 0.01%)</title><rect x="59.8821%" y="389" width="0.0103%" height="15" fill="rgb(216,127,34)" fg:x="23254" fg:w="4"/><text x="60.1321%" y="399.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (83 samples, 0.21%)</title><rect x="59.8821%" y="453" width="0.2137%" height="15" fill="rgb(234,116,52)" fg:x="23254" fg:w="83"/><text x="60.1321%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (79 samples, 0.20%)</title><rect x="59.8924%" y="437" width="0.2034%" height="15" fill="rgb(222,124,15)" fg:x="23258" fg:w="79"/><text x="60.1424%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (76 samples, 0.20%)</title><rect x="59.9001%" y="421" width="0.1957%" height="15" fill="rgb(231,179,28)" fg:x="23261" fg:w="76"/><text x="60.1501%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_swap (76 samples, 0.20%)</title><rect x="59.9001%" y="405" width="0.1957%" height="15" fill="rgb(226,93,45)" fg:x="23261" fg:w="76"/><text x="60.1501%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (87 samples, 0.22%)</title><rect x="59.8821%" y="469" width="0.2240%" height="15" fill="rgb(215,8,51)" fg:x="23254" fg:w="87"/><text x="60.1321%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (4 samples, 0.01%)</title><rect x="60.0958%" y="453" width="0.0103%" height="15" fill="rgb(223,106,5)" fg:x="23337" fg:w="4"/><text x="60.3458%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;std::collections::hash::map::HashMap&lt;core::num::nonzero::NonZeroU32,alloc::sync::Weak&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt;&gt;&gt; (88 samples, 0.23%)</title><rect x="60.1061%" y="469" width="0.2266%" height="15" fill="rgb(250,191,5)" fg:x="23341" fg:w="88"/><text x="60.3561%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (88 samples, 0.23%)</title><rect x="60.1061%" y="453" width="0.2266%" height="15" fill="rgb(242,132,44)" fg:x="23341" fg:w="88"/><text x="60.3561%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (88 samples, 0.23%)</title><rect x="60.1061%" y="437" width="0.2266%" height="15" fill="rgb(251,152,29)" fg:x="23341" fg:w="88"/><text x="60.3561%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (80 samples, 0.21%)</title><rect x="60.1267%" y="421" width="0.2060%" height="15" fill="rgb(218,179,5)" fg:x="23349" fg:w="80"/><text x="60.3767%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (80 samples, 0.21%)</title><rect x="60.1267%" y="405" width="0.2060%" height="15" fill="rgb(227,67,19)" fg:x="23349" fg:w="80"/><text x="60.3767%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (59 samples, 0.15%)</title><rect x="60.3327%" y="469" width="0.1519%" height="15" fill="rgb(233,119,31)" fg:x="23429" fg:w="59"/><text x="60.5827%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (59 samples, 0.15%)</title><rect x="60.3327%" y="453" width="0.1519%" height="15" fill="rgb(241,120,22)" fg:x="23429" fg:w="59"/><text x="60.5827%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (59 samples, 0.15%)</title><rect x="60.3327%" y="437" width="0.1519%" height="15" fill="rgb(224,102,30)" fg:x="23429" fg:w="59"/><text x="60.5827%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (54 samples, 0.14%)</title><rect x="60.3456%" y="421" width="0.1391%" height="15" fill="rgb(210,164,37)" fg:x="23434" fg:w="54"/><text x="60.5956%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (54 samples, 0.14%)</title><rect x="60.3456%" y="405" width="0.1391%" height="15" fill="rgb(226,191,16)" fg:x="23434" fg:w="54"/><text x="60.5956%" y="415.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (6 samples, 0.02%)</title><rect x="60.4872%" y="469" width="0.0155%" height="15" fill="rgb(214,40,45)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="479.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (6 samples, 0.02%)</title><rect x="60.4872%" y="453" width="0.0155%" height="15" fill="rgb(244,29,26)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="463.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (6 samples, 0.02%)</title><rect x="60.4872%" y="437" width="0.0155%" height="15" fill="rgb(216,16,5)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="447.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::add (6 samples, 0.02%)</title><rect x="60.4872%" y="421" width="0.0155%" height="15" fill="rgb(249,76,35)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="431.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::offset (6 samples, 0.02%)</title><rect x="60.4872%" y="405" width="0.0155%" height="15" fill="rgb(207,11,44)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="415.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (9 samples, 0.02%)</title><rect x="60.5593%" y="325" width="0.0232%" height="15" fill="rgb(228,190,49)" fg:x="23517" fg:w="9"/><text x="60.8093%" y="335.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::c_rounds (22 samples, 0.06%)</title><rect x="60.5413%" y="341" width="0.0567%" height="15" fill="rgb(214,173,12)" fg:x="23510" fg:w="22"/><text x="60.7913%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (6 samples, 0.02%)</title><rect x="60.5825%" y="325" width="0.0155%" height="15" fill="rgb(218,26,35)" fg:x="23526" fg:w="6"/><text x="60.8325%" y="335.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (15 samples, 0.04%)</title><rect x="60.6211%" y="325" width="0.0386%" height="15" fill="rgb(220,200,19)" fg:x="23541" fg:w="15"/><text x="60.8711%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::finish (78 samples, 0.20%)</title><rect x="60.5104%" y="389" width="0.2009%" height="15" fill="rgb(239,95,49)" fg:x="23498" fg:w="78"/><text x="60.7604%" y="399.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::finish (78 samples, 0.20%)</title><rect x="60.5104%" y="373" width="0.2009%" height="15" fill="rgb(235,85,53)" fg:x="23498" fg:w="78"/><text x="60.7604%" y="383.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::finish (78 samples, 0.20%)</title><rect x="60.5104%" y="357" width="0.2009%" height="15" fill="rgb(233,133,31)" fg:x="23498" fg:w="78"/><text x="60.7604%" y="367.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::d_rounds (44 samples, 0.11%)</title><rect x="60.5979%" y="341" width="0.1133%" height="15" fill="rgb(218,25,20)" fg:x="23532" fg:w="44"/><text x="60.8479%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (20 samples, 0.05%)</title><rect x="60.6597%" y="325" width="0.0515%" height="15" fill="rgb(252,210,38)" fg:x="23556" fg:w="20"/><text x="60.9097%" y="335.50"></text></g><g><title>hashbrown::map::make_hash (98 samples, 0.25%)</title><rect x="60.5027%" y="421" width="0.2524%" height="15" fill="rgb(242,134,21)" fg:x="23495" fg:w="98"/><text x="60.7527%" y="431.50"></text></g><g><title>core::hash::BuildHasher::hash_one (98 samples, 0.25%)</title><rect x="60.5027%" y="405" width="0.2524%" height="15" fill="rgb(213,28,48)" fg:x="23495" fg:w="98"/><text x="60.7527%" y="415.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (15 samples, 0.04%)</title><rect x="60.7164%" y="389" width="0.0386%" height="15" fill="rgb(250,196,2)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="399.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (15 samples, 0.04%)</title><rect x="60.7164%" y="373" width="0.0386%" height="15" fill="rgb(227,5,17)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="383.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for u32&gt;::hash (15 samples, 0.04%)</title><rect x="60.7164%" y="357" width="0.0386%" height="15" fill="rgb(221,226,24)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="367.50"></text></g><g><title>core::hash::Hasher::write_u32 (15 samples, 0.04%)</title><rect x="60.7164%" y="341" width="0.0386%" height="15" fill="rgb(211,5,48)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="351.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::write (15 samples, 0.04%)</title><rect x="60.7164%" y="325" width="0.0386%" height="15" fill="rgb(219,150,6)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="335.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::write (15 samples, 0.04%)</title><rect x="60.7164%" y="309" width="0.0386%" height="15" fill="rgb(251,46,16)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="319.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::write (15 samples, 0.04%)</title><rect x="60.7164%" y="293" width="0.0386%" height="15" fill="rgb(220,204,40)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="303.50"></text></g><g><title>core::hash::sip::u8to64_le (10 samples, 0.03%)</title><rect x="60.7293%" y="277" width="0.0258%" height="15" fill="rgb(211,85,2)" fg:x="23583" fg:w="10"/><text x="60.9793%" y="287.50"></text></g><g><title>&lt;hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator&gt;::next (6 samples, 0.02%)</title><rect x="60.7808%" y="373" width="0.0155%" height="15" fill="rgb(229,17,7)" fg:x="23603" fg:w="6"/><text x="61.0308%" y="383.50"></text></g><g><title>hashbrown::map::equivalent_key::_{{closure}} (10 samples, 0.03%)</title><rect x="60.7962%" y="357" width="0.0258%" height="15" fill="rgb(239,72,28)" fg:x="23609" fg:w="10"/><text x="61.0462%" y="367.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::cmp::PartialEq&gt;::eq (10 samples, 0.03%)</title><rect x="60.7962%" y="341" width="0.0258%" height="15" fill="rgb(230,47,54)" fg:x="23609" fg:w="10"/><text x="61.0462%" y="351.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find::_{{closure}} (17 samples, 0.04%)</title><rect x="60.7962%" y="373" width="0.0438%" height="15" fill="rgb(214,50,8)" fg:x="23609" fg:w="17"/><text x="61.0462%" y="383.50"></text></g><g><title>hashbrown::raw::Bucket&lt;T&gt;::as_ref (7 samples, 0.02%)</title><rect x="60.8220%" y="357" width="0.0180%" height="15" fill="rgb(216,198,43)" fg:x="23619" fg:w="7"/><text x="61.0720%" y="367.50"></text></g><g><title>hashbrown::raw::Bucket&lt;T&gt;::as_ptr (7 samples, 0.02%)</title><rect x="60.8220%" y="341" width="0.0180%" height="15" fill="rgb(234,20,35)" fg:x="23619" fg:w="7"/><text x="61.0720%" y="351.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::sub (7 samples, 0.02%)</title><rect x="60.8220%" y="325" width="0.0180%" height="15" fill="rgb(254,45,19)" fg:x="23619" fg:w="7"/><text x="61.0720%" y="335.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::offset (7 samples, 0.02%)</title><rect x="60.8220%" y="309" width="0.0180%" height="15" fill="rgb(219,14,44)" fg:x="23619" fg:w="7"/><text x="61.0720%" y="319.50"></text></g><g><title>hashbrown::raw::h2 (14 samples, 0.04%)</title><rect x="60.8400%" y="373" width="0.0361%" height="15" fill="rgb(217,220,26)" fg:x="23626" fg:w="14"/><text x="61.0900%" y="383.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (149 samples, 0.38%)</title><rect x="60.5027%" y="437" width="0.3837%" height="15" fill="rgb(213,158,28)" fg:x="23495" fg:w="149"/><text x="60.7527%" y="447.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::get (51 samples, 0.13%)</title><rect x="60.7550%" y="421" width="0.1313%" height="15" fill="rgb(252,51,52)" fg:x="23593" fg:w="51"/><text x="61.0050%" y="431.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find (51 samples, 0.13%)</title><rect x="60.7550%" y="405" width="0.1313%" height="15" fill="rgb(246,89,16)" fg:x="23593" fg:w="51"/><text x="61.0050%" y="415.50"></text></g><g><title>hashbrown::raw::RawTableInner&lt;A&gt;::find_inner (51 samples, 0.13%)</title><rect x="60.7550%" y="389" width="0.1313%" height="15" fill="rgb(216,158,49)" fg:x="23593" fg:w="51"/><text x="61.0050%" y="399.50"></text></g><g><title>hashbrown::raw::sse2::Group::match_byte (4 samples, 0.01%)</title><rect x="60.8761%" y="373" width="0.0103%" height="15" fill="rgb(236,107,19)" fg:x="23640" fg:w="4"/><text x="61.1261%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_movemask_epi8 (4 samples, 0.01%)</title><rect x="60.8761%" y="357" width="0.0103%" height="15" fill="rgb(228,185,30)" fg:x="23640" fg:w="4"/><text x="61.1261%" y="367.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (153 samples, 0.39%)</title><rect x="60.5027%" y="469" width="0.3940%" height="15" fill="rgb(246,134,8)" fg:x="23495" fg:w="153"/><text x="60.7527%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (153 samples, 0.39%)</title><rect x="60.5027%" y="453" width="0.3940%" height="15" fill="rgb(214,143,50)" fg:x="23495" fg:w="153"/><text x="60.7527%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (4 samples, 0.01%)</title><rect x="60.8864%" y="437" width="0.0103%" height="15" fill="rgb(228,75,8)" fg:x="23644" fg:w="4"/><text x="61.1364%" y="447.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (5 samples, 0.01%)</title><rect x="60.8992%" y="453" width="0.0129%" height="15" fill="rgb(207,175,4)" fg:x="23649" fg:w="5"/><text x="61.1492%" y="463.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (50 samples, 0.13%)</title><rect x="60.8967%" y="469" width="0.1288%" height="15" fill="rgb(205,108,24)" fg:x="23648" fg:w="50"/><text x="61.1467%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (44 samples, 0.11%)</title><rect x="60.9121%" y="453" width="0.1133%" height="15" fill="rgb(244,120,49)" fg:x="23654" fg:w="44"/><text x="61.1621%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (42 samples, 0.11%)</title><rect x="60.9173%" y="437" width="0.1082%" height="15" fill="rgb(223,47,38)" fg:x="23656" fg:w="42"/><text x="61.1673%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (42 samples, 0.11%)</title><rect x="60.9173%" y="421" width="0.1082%" height="15" fill="rgb(229,179,11)" fg:x="23656" fg:w="42"/><text x="61.1673%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (135 samples, 0.35%)</title><rect x="61.0640%" y="437" width="0.3476%" height="15" fill="rgb(231,122,1)" fg:x="23713" fg:w="135"/><text x="61.3140%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (135 samples, 0.35%)</title><rect x="61.0640%" y="421" width="0.3476%" height="15" fill="rgb(245,119,9)" fg:x="23713" fg:w="135"/><text x="61.3140%" y="431.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (158 samples, 0.41%)</title><rect x="61.0254%" y="469" width="0.4069%" height="15" fill="rgb(241,163,25)" fg:x="23698" fg:w="158"/><text x="61.2754%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (158 samples, 0.41%)</title><rect x="61.0254%" y="453" width="0.4069%" height="15" fill="rgb(217,214,3)" fg:x="23698" fg:w="158"/><text x="61.2754%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::is_read_lockable (8 samples, 0.02%)</title><rect x="61.4117%" y="437" width="0.0206%" height="15" fill="rgb(240,86,28)" fg:x="23848" fg:w="8"/><text x="61.6617%" y="447.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::check (10 samples, 0.03%)</title><rect x="61.4323%" y="469" width="0.0258%" height="15" fill="rgb(215,47,9)" fg:x="23856" fg:w="10"/><text x="61.6823%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicU64::load (6 samples, 0.02%)</title><rect x="61.4426%" y="453" width="0.0155%" height="15" fill="rgb(252,25,45)" fg:x="23860" fg:w="6"/><text x="61.6926%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="61.4426%" y="437" width="0.0155%" height="15" fill="rgb(251,164,9)" fg:x="23860" fg:w="6"/><text x="61.6926%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::push (19 samples, 0.05%)</title><rect x="61.5121%" y="453" width="0.0489%" height="15" fill="rgb(233,194,0)" fg:x="23887" fg:w="19"/><text x="61.7621%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push (19 samples, 0.05%)</title><rect x="61.5121%" y="437" width="0.0489%" height="15" fill="rgb(249,111,24)" fg:x="23887" fg:w="19"/><text x="61.7621%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::try_push (19 samples, 0.05%)</title><rect x="61.5121%" y="421" width="0.0489%" height="15" fill="rgb(250,223,3)" fg:x="23887" fg:w="19"/><text x="61.7621%" y="431.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push_unchecked (11 samples, 0.03%)</title><rect x="61.5327%" y="405" width="0.0283%" height="15" fill="rgb(236,178,37)" fg:x="23895" fg:w="11"/><text x="61.7827%" y="415.50"></text></g><g><title>core::ptr::write (11 samples, 0.03%)</title><rect x="61.5327%" y="389" width="0.0283%" height="15" fill="rgb(241,158,50)" fg:x="23895" fg:w="11"/><text x="61.7827%" y="399.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (59 samples, 0.15%)</title><rect x="61.4580%" y="469" width="0.1519%" height="15" fill="rgb(213,121,41)" fg:x="23866" fg:w="59"/><text x="61.7080%" y="479.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (39 samples, 0.10%)</title><rect x="61.6151%" y="453" width="0.1004%" height="15" fill="rgb(240,92,3)" fg:x="23927" fg:w="39"/><text x="61.8651%" y="463.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (39 samples, 0.10%)</title><rect x="61.6151%" y="437" width="0.1004%" height="15" fill="rgb(205,123,3)" fg:x="23927" fg:w="39"/><text x="61.8651%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (39 samples, 0.10%)</title><rect x="61.6151%" y="421" width="0.1004%" height="15" fill="rgb(205,97,47)" fg:x="23927" fg:w="39"/><text x="61.8651%" y="431.50"></text></g><g><title>zssp::zeta::from_nonce (44 samples, 0.11%)</title><rect x="61.6100%" y="469" width="0.1133%" height="15" fill="rgb(247,152,14)" fg:x="23925" fg:w="44"/><text x="61.8600%" y="479.50"></text></g><g><title>&lt;core::slice::iter::IterMut&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::next (4 samples, 0.01%)</title><rect x="61.7774%" y="453" width="0.0103%" height="15" fill="rgb(248,195,53)" fg:x="23990" fg:w="4"/><text x="62.0274%" y="463.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (60 samples, 0.15%)</title><rect x="61.7877%" y="453" width="0.1545%" height="15" fill="rgb(226,201,16)" fg:x="23994" fg:w="60"/><text x="62.0377%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (60 samples, 0.15%)</title><rect x="61.7877%" y="437" width="0.1545%" height="15" fill="rgb(205,98,0)" fg:x="23994" fg:w="60"/><text x="62.0377%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (60 samples, 0.15%)</title><rect x="61.7877%" y="421" width="0.1545%" height="15" fill="rgb(214,191,48)" fg:x="23994" fg:w="60"/><text x="62.0377%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (60 samples, 0.15%)</title><rect x="61.7877%" y="405" width="0.1545%" height="15" fill="rgb(237,112,39)" fg:x="23994" fg:w="60"/><text x="62.0377%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_get_block_size (5 samples, 0.01%)</title><rect x="62.1713%" y="405" width="0.0129%" height="15" fill="rgb(247,203,27)" fg:x="24143" fg:w="5"/><text x="62.4213%" y="415.50"></text></g><g><title>CRYPTO_gcm128_decrypt (268 samples, 0.69%)</title><rect x="62.3722%" y="357" width="0.6901%" height="15" fill="rgb(235,124,28)" fg:x="24221" fg:w="268"/><text x="62.6222%" y="367.50"></text></g><g><title>[libcrypto.so.3] (104 samples, 0.27%)</title><rect x="62.7945%" y="341" width="0.2678%" height="15" fill="rgb(208,207,46)" fg:x="24385" fg:w="104"/><text x="63.0445%" y="351.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (512 samples, 1.32%)</title><rect x="63.0623%" y="357" width="1.3185%" height="15" fill="rgb(234,176,4)" fg:x="24489" fg:w="512"/><text x="63.3123%" y="367.50"></text></g><g><title>[libcrypto.so.3] (396 samples, 1.02%)</title><rect x="63.3611%" y="341" width="1.0198%" height="15" fill="rgb(230,133,28)" fg:x="24605" fg:w="396"/><text x="63.6111%" y="351.50"></text></g><g><title>[libcrypto.so.3] (25 samples, 0.06%)</title><rect x="64.3164%" y="325" width="0.0644%" height="15" fill="rgb(211,137,40)" fg:x="24976" fg:w="25"/><text x="64.5664%" y="335.50"></text></g><g><title>CRYPTO_gcm128_setiv (25 samples, 0.06%)</title><rect x="64.3808%" y="357" width="0.0644%" height="15" fill="rgb(254,35,13)" fg:x="25001" fg:w="25"/><text x="64.6308%" y="367.50"></text></g><g><title>[libcrypto.so.3] (22 samples, 0.06%)</title><rect x="64.3885%" y="341" width="0.0567%" height="15" fill="rgb(225,49,51)" fg:x="25004" fg:w="22"/><text x="64.6385%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (4,728 samples, 12.18%)</title><rect x="61.9422%" y="453" width="12.1752%" height="15" fill="rgb(251,10,15)" fg:x="24054" fg:w="4728"/><text x="62.1922%" y="463.50">&lt;zssp::crypto_impl..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4,725 samples, 12.17%)</title><rect x="61.9499%" y="437" width="12.1675%" height="15" fill="rgb(228,207,15)" fg:x="24057" fg:w="4725"/><text x="62.1999%" y="447.50">zssp::crypto_impl:..</text></g><g><title>EVP_DecryptUpdate (4,725 samples, 12.17%)</title><rect x="61.9499%" y="421" width="12.1675%" height="15" fill="rgb(241,99,19)" fg:x="24057" fg:w="4725"/><text x="62.1999%" y="431.50">EVP_DecryptUpdate</text></g><g><title>[libcrypto.so.3] (4,634 samples, 11.93%)</title><rect x="62.1842%" y="405" width="11.9331%" height="15" fill="rgb(207,104,49)" fg:x="24148" fg:w="4634"/><text x="62.4342%" y="415.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,632 samples, 11.93%)</title><rect x="62.1894%" y="389" width="11.9280%" height="15" fill="rgb(234,99,18)" fg:x="24150" fg:w="4632"/><text x="62.4394%" y="399.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,611 samples, 11.87%)</title><rect x="62.2435%" y="373" width="11.8739%" height="15" fill="rgb(213,191,49)" fg:x="24171" fg:w="4611"/><text x="62.4935%" y="383.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,756 samples, 9.67%)</title><rect x="64.4452%" y="357" width="9.6722%" height="15" fill="rgb(210,226,19)" fg:x="25026" fg:w="3756"/><text x="64.6952%" y="367.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,594 samples, 9.26%)</title><rect x="64.8624%" y="341" width="9.2550%" height="15" fill="rgb(229,97,18)" fg:x="25188" fg:w="3594"/><text x="65.1124%" y="351.50">[libcrypto.so..</text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec&gt; (7 samples, 0.02%)</title><rect x="74.1174%" y="437" width="0.0180%" height="15" fill="rgb(211,167,15)" fg:x="28782" fg:w="7"/><text x="74.3674%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (7 samples, 0.02%)</title><rect x="74.1174%" y="421" width="0.0180%" height="15" fill="rgb(210,169,34)" fg:x="28782" fg:w="7"/><text x="74.3674%" y="431.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="74.1174%" y="405" width="0.0180%" height="15" fill="rgb(241,121,31)" fg:x="28782" fg:w="7"/><text x="74.3674%" y="415.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (6 samples, 0.02%)</title><rect x="74.1199%" y="389" width="0.0155%" height="15" fill="rgb(232,40,11)" fg:x="28783" fg:w="6"/><text x="74.3699%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (6 samples, 0.02%)</title><rect x="74.1199%" y="373" width="0.0155%" height="15" fill="rgb(205,86,26)" fg:x="28783" fg:w="6"/><text x="74.3699%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_swap (6 samples, 0.02%)</title><rect x="74.1199%" y="357" width="0.0155%" height="15" fill="rgb(231,126,28)" fg:x="28783" fg:w="6"/><text x="74.3699%" y="367.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="74.2075%" y="341" width="0.0103%" height="15" fill="rgb(219,221,18)" fg:x="28817" fg:w="4"/><text x="74.4575%" y="351.50"></text></g><g><title>CRYPTO_gcm128_finish (47 samples, 0.12%)</title><rect x="74.1689%" y="357" width="0.1210%" height="15" fill="rgb(211,40,0)" fg:x="28802" fg:w="47"/><text x="74.4189%" y="367.50"></text></g><g><title>[libcrypto.so.3] (28 samples, 0.07%)</title><rect x="74.2178%" y="341" width="0.0721%" height="15" fill="rgb(239,85,43)" fg:x="28821" fg:w="28"/><text x="74.4678%" y="351.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (63 samples, 0.16%)</title><rect x="74.1354%" y="437" width="0.1622%" height="15" fill="rgb(231,55,21)" fg:x="28789" fg:w="63"/><text x="74.3854%" y="447.50"></text></g><g><title>EVP_DecryptFinal_ex (63 samples, 0.16%)</title><rect x="74.1354%" y="421" width="0.1622%" height="15" fill="rgb(225,184,43)" fg:x="28789" fg:w="63"/><text x="74.3854%" y="431.50"></text></g><g><title>[libcrypto.so.3] (58 samples, 0.15%)</title><rect x="74.1483%" y="405" width="0.1494%" height="15" fill="rgb(251,158,41)" fg:x="28794" fg:w="58"/><text x="74.3983%" y="415.50"></text></g><g><title>[libcrypto.so.3] (56 samples, 0.14%)</title><rect x="74.1534%" y="389" width="0.1442%" height="15" fill="rgb(234,159,37)" fg:x="28796" fg:w="56"/><text x="74.4034%" y="399.50"></text></g><g><title>[libcrypto.so.3] (51 samples, 0.13%)</title><rect x="74.1663%" y="373" width="0.1313%" height="15" fill="rgb(216,204,22)" fg:x="28801" fg:w="51"/><text x="74.4163%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (27 samples, 0.07%)</title><rect x="74.4341%" y="389" width="0.0695%" height="15" fill="rgb(214,17,3)" fg:x="28905" fg:w="27"/><text x="74.6841%" y="399.50"></text></g><g><title>[libc.so.6] (12 samples, 0.03%)</title><rect x="74.4727%" y="373" width="0.0309%" height="15" fill="rgb(212,111,17)" fg:x="28920" fg:w="12"/><text x="74.7227%" y="383.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (152 samples, 0.39%)</title><rect x="74.1174%" y="453" width="0.3914%" height="15" fill="rgb(221,157,24)" fg:x="28782" fg:w="152"/><text x="74.3674%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::set_tag (82 samples, 0.21%)</title><rect x="74.2976%" y="437" width="0.2112%" height="15" fill="rgb(252,16,13)" fg:x="28852" fg:w="82"/><text x="74.5476%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (82 samples, 0.21%)</title><rect x="74.2976%" y="421" width="0.2112%" height="15" fill="rgb(221,62,2)" fg:x="28852" fg:w="82"/><text x="74.5476%" y="431.50"></text></g><g><title>[libcrypto.so.3] (41 samples, 0.11%)</title><rect x="74.4032%" y="405" width="0.1056%" height="15" fill="rgb(247,87,22)" fg:x="28893" fg:w="41"/><text x="74.6532%" y="415.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (16 samples, 0.04%)</title><rect x="74.5088%" y="437" width="0.0412%" height="15" fill="rgb(215,73,9)" fg:x="28934" fg:w="16"/><text x="74.7588%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (16 samples, 0.04%)</title><rect x="74.5088%" y="421" width="0.0412%" height="15" fill="rgb(207,175,33)" fg:x="28934" fg:w="16"/><text x="74.7588%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (15 samples, 0.04%)</title><rect x="74.5114%" y="405" width="0.0386%" height="15" fill="rgb(243,129,54)" fg:x="28935" fg:w="15"/><text x="74.7614%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (15 samples, 0.04%)</title><rect x="74.5114%" y="389" width="0.0386%" height="15" fill="rgb(227,119,45)" fg:x="28935" fg:w="15"/><text x="74.7614%" y="399.50"></text></g><g><title>[libc.so.6] (22 samples, 0.06%)</title><rect x="74.7483%" y="341" width="0.0567%" height="15" fill="rgb(205,109,36)" fg:x="29027" fg:w="22"/><text x="74.9983%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (47 samples, 0.12%)</title><rect x="74.6865%" y="357" width="0.1210%" height="15" fill="rgb(205,6,39)" fg:x="29003" fg:w="47"/><text x="74.9365%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (68 samples, 0.18%)</title><rect x="74.6350%" y="389" width="0.1751%" height="15" fill="rgb(221,32,16)" fg:x="28983" fg:w="68"/><text x="74.8850%" y="399.50"></text></g><g><title>[libcrypto.so.3] (52 samples, 0.13%)</title><rect x="74.6762%" y="373" width="0.1339%" height="15" fill="rgb(228,144,50)" fg:x="28999" fg:w="52"/><text x="74.9262%" y="383.50"></text></g><g><title>[libc.so.6] (27 samples, 0.07%)</title><rect x="74.9285%" y="341" width="0.0695%" height="15" fill="rgb(229,201,53)" fg:x="29097" fg:w="27"/><text x="75.1785%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (49 samples, 0.13%)</title><rect x="74.8899%" y="357" width="0.1262%" height="15" fill="rgb(249,153,27)" fg:x="29082" fg:w="49"/><text x="75.1399%" y="367.50"></text></g><g><title>strcmp@plt (7 samples, 0.02%)</title><rect x="74.9981%" y="341" width="0.0180%" height="15" fill="rgb(227,106,25)" fg:x="29124" fg:w="7"/><text x="75.2481%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (86 samples, 0.22%)</title><rect x="74.8101%" y="389" width="0.2215%" height="15" fill="rgb(230,65,29)" fg:x="29051" fg:w="86"/><text x="75.0601%" y="399.50"></text></g><g><title>[libcrypto.so.3] (66 samples, 0.17%)</title><rect x="74.8616%" y="373" width="0.1700%" height="15" fill="rgb(221,57,46)" fg:x="29071" fg:w="66"/><text x="75.1116%" y="383.50"></text></g><g><title>OSSL_PARAM_locate_const (6 samples, 0.02%)</title><rect x="75.0161%" y="357" width="0.0155%" height="15" fill="rgb(229,161,17)" fg:x="29131" fg:w="6"/><text x="75.2661%" y="367.50"></text></g><g><title>EVP_CIPHER_free (15 samples, 0.04%)</title><rect x="75.0315%" y="389" width="0.0386%" height="15" fill="rgb(222,213,11)" fg:x="29137" fg:w="15"/><text x="75.2815%" y="399.50"></text></g><g><title>EVP_CipherInit_ex (252 samples, 0.65%)</title><rect x="74.5526%" y="421" width="0.6489%" height="15" fill="rgb(235,35,13)" fg:x="28951" fg:w="252"/><text x="74.8026%" y="431.50"></text></g><g><title>[libcrypto.so.3] (252 samples, 0.65%)</title><rect x="74.5526%" y="405" width="0.6489%" height="15" fill="rgb(233,158,34)" fg:x="28951" fg:w="252"/><text x="74.8026%" y="415.50"></text></g><g><title>EVP_CIPHER_up_ref (51 samples, 0.13%)</title><rect x="75.0702%" y="389" width="0.1313%" height="15" fill="rgb(215,151,48)" fg:x="29152" fg:w="51"/><text x="75.3202%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (270 samples, 0.70%)</title><rect x="74.5088%" y="453" width="0.6953%" height="15" fill="rgb(229,84,14)" fg:x="28934" fg:w="270"/><text x="74.7588%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (254 samples, 0.65%)</title><rect x="74.5500%" y="437" width="0.6541%" height="15" fill="rgb(229,68,14)" fg:x="28950" fg:w="254"/><text x="74.8000%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (7 samples, 0.02%)</title><rect x="75.2118%" y="453" width="0.0180%" height="15" fill="rgb(243,106,26)" fg:x="29207" fg:w="7"/><text x="75.4618%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (7 samples, 0.02%)</title><rect x="75.2118%" y="437" width="0.0180%" height="15" fill="rgb(206,45,38)" fg:x="29207" fg:w="7"/><text x="75.4618%" y="447.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (4 samples, 0.01%)</title><rect x="75.2195%" y="421" width="0.0103%" height="15" fill="rgb(226,6,15)" fg:x="29210" fg:w="4"/><text x="75.4695%" y="431.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (4 samples, 0.01%)</title><rect x="75.2195%" y="405" width="0.0103%" height="15" fill="rgb(232,22,54)" fg:x="29210" fg:w="4"/><text x="75.4695%" y="415.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::remaining_capacity (5 samples, 0.01%)</title><rect x="75.2298%" y="421" width="0.0129%" height="15" fill="rgb(229,222,32)" fg:x="29214" fg:w="5"/><text x="75.4798%" y="431.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (240 samples, 0.62%)</title><rect x="75.2427%" y="421" width="0.6180%" height="15" fill="rgb(228,62,29)" fg:x="29219" fg:w="240"/><text x="75.4927%" y="431.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (238 samples, 0.61%)</title><rect x="75.2479%" y="405" width="0.6129%" height="15" fill="rgb(251,103,34)" fg:x="29221" fg:w="238"/><text x="75.4979%" y="415.50"></text></g><g><title>[libc.so.6] (238 samples, 0.61%)</title><rect x="75.2479%" y="389" width="0.6129%" height="15" fill="rgb(233,12,30)" fg:x="29221" fg:w="238"/><text x="75.4979%" y="399.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (247 samples, 0.64%)</title><rect x="75.2298%" y="453" width="0.6361%" height="15" fill="rgb(238,52,0)" fg:x="29214" fg:w="247"/><text x="75.4798%" y="463.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (247 samples, 0.64%)</title><rect x="75.2298%" y="437" width="0.6361%" height="15" fill="rgb(223,98,5)" fg:x="29214" fg:w="247"/><text x="75.4798%" y="447.50"></text></g><g><title>zssp::zeta::receive_payload_in_place (5,500 samples, 14.16%)</title><rect x="61.7233%" y="469" width="14.1632%" height="15" fill="rgb(228,75,37)" fg:x="23969" fg:w="5500"/><text x="61.9733%" y="479.50">zssp::zeta::receive_pa..</text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::update (8 samples, 0.02%)</title><rect x="75.8659%" y="453" width="0.0206%" height="15" fill="rgb(205,115,49)" fg:x="29461" fg:w="8"/><text x="76.1159%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_max (8 samples, 0.02%)</title><rect x="75.8659%" y="437" width="0.0206%" height="15" fill="rgb(250,154,43)" fg:x="29461" fg:w="8"/><text x="76.1159%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_umax (8 samples, 0.02%)</title><rect x="75.8659%" y="421" width="0.0206%" height="15" fill="rgb(226,43,29)" fg:x="29461" fg:w="8"/><text x="76.1159%" y="431.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8,391 samples, 21.61%)</title><rect x="54.5387%" y="485" width="21.6079%" height="15" fill="rgb(249,228,39)" fg:x="21179" fg:w="8391"/><text x="54.7887%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::recei..</text></g><g><title>zssp::zssp::parse_fragment_header (101 samples, 0.26%)</title><rect x="75.8865%" y="469" width="0.2601%" height="15" fill="rgb(216,79,43)" fg:x="29469" fg:w="101"/><text x="76.1365%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (73 samples, 0.19%)</title><rect x="76.2213%" y="437" width="0.1880%" height="15" fill="rgb(228,95,12)" fg:x="29599" fg:w="73"/><text x="76.4713%" y="447.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (73 samples, 0.19%)</title><rect x="76.2213%" y="421" width="0.1880%" height="15" fill="rgb(249,221,15)" fg:x="29599" fg:w="73"/><text x="76.4713%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (70 samples, 0.18%)</title><rect x="76.2290%" y="405" width="0.1803%" height="15" fill="rgb(233,34,13)" fg:x="29602" fg:w="70"/><text x="76.4790%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (66 samples, 0.17%)</title><rect x="76.2393%" y="389" width="0.1700%" height="15" fill="rgb(214,103,39)" fg:x="29606" fg:w="66"/><text x="76.4893%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_swap (66 samples, 0.17%)</title><rect x="76.2393%" y="373" width="0.1700%" height="15" fill="rgb(251,126,39)" fg:x="29606" fg:w="66"/><text x="76.4893%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (77 samples, 0.20%)</title><rect x="76.4092%" y="437" width="0.1983%" height="15" fill="rgb(214,216,36)" fg:x="29672" fg:w="77"/><text x="76.6592%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (76 samples, 0.20%)</title><rect x="76.4118%" y="421" width="0.1957%" height="15" fill="rgb(220,221,8)" fg:x="29673" fg:w="76"/><text x="76.6618%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (73 samples, 0.19%)</title><rect x="76.4195%" y="405" width="0.1880%" height="15" fill="rgb(240,216,3)" fg:x="29676" fg:w="73"/><text x="76.6695%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (73 samples, 0.19%)</title><rect x="76.4195%" y="389" width="0.1880%" height="15" fill="rgb(232,218,17)" fg:x="29676" fg:w="73"/><text x="76.6695%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (321 samples, 0.83%)</title><rect x="76.1981%" y="453" width="0.8266%" height="15" fill="rgb(229,163,45)" fg:x="29590" fg:w="321"/><text x="76.4481%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (162 samples, 0.42%)</title><rect x="76.6075%" y="437" width="0.4172%" height="15" fill="rgb(231,110,42)" fg:x="29749" fg:w="162"/><text x="76.8575%" y="447.50"></text></g><g><title>EVP_EncryptUpdate (158 samples, 0.41%)</title><rect x="76.6178%" y="421" width="0.4069%" height="15" fill="rgb(208,170,48)" fg:x="29753" fg:w="158"/><text x="76.8678%" y="431.50"></text></g><g><title>[libcrypto.so.3] (139 samples, 0.36%)</title><rect x="76.6668%" y="405" width="0.3579%" height="15" fill="rgb(239,116,25)" fg:x="29772" fg:w="139"/><text x="76.9168%" y="415.50"></text></g><g><title>[libcrypto.so.3] (108 samples, 0.28%)</title><rect x="76.7466%" y="389" width="0.2781%" height="15" fill="rgb(219,200,50)" fg:x="29803" fg:w="108"/><text x="76.9966%" y="399.50"></text></g><g><title>[libcrypto.so.3] (99 samples, 0.25%)</title><rect x="76.7698%" y="373" width="0.2549%" height="15" fill="rgb(245,200,0)" fg:x="29812" fg:w="99"/><text x="77.0198%" y="383.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="77.0118%" y="357" width="0.0129%" height="15" fill="rgb(245,119,33)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="367.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="77.0118%" y="341" width="0.0129%" height="15" fill="rgb(231,125,12)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="351.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="77.0118%" y="325" width="0.0129%" height="15" fill="rgb(216,96,41)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="335.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="77.0118%" y="309" width="0.0129%" height="15" fill="rgb(248,43,45)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="319.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="77.0118%" y="293" width="0.0129%" height="15" fill="rgb(217,222,7)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="303.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="77.0118%" y="277" width="0.0129%" height="15" fill="rgb(233,28,6)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="287.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="77.0118%" y="261" width="0.0129%" height="15" fill="rgb(231,218,15)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="271.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="77.0118%" y="245" width="0.0129%" height="15" fill="rgb(226,171,48)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="255.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="77.0118%" y="229" width="0.0129%" height="15" fill="rgb(235,201,9)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="239.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="77.0118%" y="213" width="0.0129%" height="15" fill="rgb(217,80,15)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="223.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="77.0118%" y="197" width="0.0129%" height="15" fill="rgb(219,152,8)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="207.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::deref::Deref&gt;::deref (10 samples, 0.03%)</title><rect x="77.0247%" y="437" width="0.0258%" height="15" fill="rgb(243,107,38)" fg:x="29911" fg:w="10"/><text x="77.2747%" y="447.50"></text></g><g><title>[libcrypto.so.3] (174 samples, 0.45%)</title><rect x="77.6118%" y="341" width="0.4481%" height="15" fill="rgb(231,17,5)" fg:x="30139" fg:w="174"/><text x="77.8618%" y="351.50"></text></g><g><title>CRYPTO_gcm128_encrypt (280 samples, 0.72%)</title><rect x="77.3517%" y="357" width="0.7210%" height="15" fill="rgb(209,25,54)" fg:x="30038" fg:w="280"/><text x="77.6017%" y="367.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="78.0599%" y="341" width="0.0129%" height="15" fill="rgb(219,0,2)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="78.0599%" y="325" width="0.0129%" height="15" fill="rgb(246,9,5)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="335.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="78.0599%" y="309" width="0.0129%" height="15" fill="rgb(226,159,4)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="78.0599%" y="293" width="0.0129%" height="15" fill="rgb(219,175,34)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="78.0599%" y="277" width="0.0129%" height="15" fill="rgb(236,10,46)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="78.0599%" y="261" width="0.0129%" height="15" fill="rgb(240,211,16)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="78.0599%" y="245" width="0.0129%" height="15" fill="rgb(205,3,43)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="78.0599%" y="229" width="0.0129%" height="15" fill="rgb(245,7,22)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="239.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="78.0599%" y="213" width="0.0129%" height="15" fill="rgb(239,132,32)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="78.0599%" y="197" width="0.0129%" height="15" fill="rgb(228,202,34)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="207.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="78.0599%" y="181" width="0.0129%" height="15" fill="rgb(254,200,22)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="191.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (476 samples, 1.23%)</title><rect x="78.0728%" y="357" width="1.2258%" height="15" fill="rgb(219,10,39)" fg:x="30318" fg:w="476"/><text x="78.3228%" y="367.50"></text></g><g><title>[libcrypto.so.3] (345 samples, 0.89%)</title><rect x="78.4101%" y="341" width="0.8884%" height="15" fill="rgb(226,210,39)" fg:x="30449" fg:w="345"/><text x="78.6601%" y="351.50"></text></g><g><title>[libcrypto.so.3] (31 samples, 0.08%)</title><rect x="79.2187%" y="325" width="0.0798%" height="15" fill="rgb(208,219,16)" fg:x="30763" fg:w="31"/><text x="79.4687%" y="335.50"></text></g><g><title>CRYPTO_gcm128_setiv (18 samples, 0.05%)</title><rect x="79.2985%" y="357" width="0.0464%" height="15" fill="rgb(216,158,51)" fg:x="30794" fg:w="18"/><text x="79.5485%" y="367.50"></text></g><g><title>[libcrypto.so.3] (15 samples, 0.04%)</title><rect x="79.3063%" y="341" width="0.0386%" height="15" fill="rgb(233,14,44)" fg:x="30797" fg:w="15"/><text x="79.5563%" y="351.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="87.0625%" y="165" width="0.0129%" height="15" fill="rgb(237,97,39)" fg:x="33809" fg:w="5"/><text x="87.3125%" y="175.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (3,908 samples, 10.06%)</title><rect x="77.0247%" y="453" width="10.0636%" height="15" fill="rgb(218,198,43)" fg:x="29911" fg:w="3908"/><text x="77.2747%" y="463.50">&lt;zssp::crypto_i..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (3,898 samples, 10.04%)</title><rect x="77.0504%" y="437" width="10.0379%" height="15" fill="rgb(231,104,20)" fg:x="29921" fg:w="3898"/><text x="77.3004%" y="447.50">zssp::crypto_im..</text></g><g><title>EVP_EncryptUpdate (3,895 samples, 10.03%)</title><rect x="77.0582%" y="421" width="10.0301%" height="15" fill="rgb(254,36,13)" fg:x="29924" fg:w="3895"/><text x="77.3082%" y="431.50">EVP_EncryptUpda..</text></g><g><title>[libcrypto.so.3] (3,844 samples, 9.90%)</title><rect x="77.1895%" y="405" width="9.8988%" height="15" fill="rgb(248,14,50)" fg:x="29975" fg:w="3844"/><text x="77.4395%" y="415.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,838 samples, 9.88%)</title><rect x="77.2050%" y="389" width="9.8833%" height="15" fill="rgb(217,107,29)" fg:x="29981" fg:w="3838"/><text x="77.4550%" y="399.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,819 samples, 9.83%)</title><rect x="77.2539%" y="373" width="9.8344%" height="15" fill="rgb(251,169,33)" fg:x="30000" fg:w="3819"/><text x="77.5039%" y="383.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,007 samples, 7.74%)</title><rect x="79.3449%" y="357" width="7.7434%" height="15" fill="rgb(217,108,32)" fg:x="30812" fg:w="3007"/><text x="79.5949%" y="367.50">[libcrypto...</text></g><g><title>[libcrypto.so.3] (2,753 samples, 7.09%)</title><rect x="79.9990%" y="341" width="7.0893%" height="15" fill="rgb(219,66,42)" fg:x="31066" fg:w="2753"/><text x="80.2490%" y="351.50">[libcrypto..</text></g><g><title>asm_sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="87.0625%" y="325" width="0.0258%" height="15" fill="rgb(206,180,7)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="87.0625%" y="309" width="0.0258%" height="15" fill="rgb(208,226,31)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="319.50"></text></g><g><title>irqentry_exit (10 samples, 0.03%)</title><rect x="87.0625%" y="293" width="0.0258%" height="15" fill="rgb(218,26,49)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (10 samples, 0.03%)</title><rect x="87.0625%" y="277" width="0.0258%" height="15" fill="rgb(233,197,48)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (10 samples, 0.03%)</title><rect x="87.0625%" y="261" width="0.0258%" height="15" fill="rgb(252,181,51)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (10 samples, 0.03%)</title><rect x="87.0625%" y="245" width="0.0258%" height="15" fill="rgb(253,90,19)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="255.50"></text></g><g><title>schedule (10 samples, 0.03%)</title><rect x="87.0625%" y="229" width="0.0258%" height="15" fill="rgb(215,171,30)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="239.50"></text></g><g><title>__schedule (10 samples, 0.03%)</title><rect x="87.0625%" y="213" width="0.0258%" height="15" fill="rgb(214,222,9)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="87.0625%" y="197" width="0.0258%" height="15" fill="rgb(223,3,22)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="87.0625%" y="181" width="0.0258%" height="15" fill="rgb(225,196,46)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="191.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="87.0754%" y="165" width="0.0129%" height="15" fill="rgb(209,110,37)" fg:x="33814" fg:w="5"/><text x="87.3254%" y="175.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc&gt; (11 samples, 0.03%)</title><rect x="87.0935%" y="437" width="0.0283%" height="15" fill="rgb(249,89,12)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (11 samples, 0.03%)</title><rect x="87.0935%" y="421" width="0.0283%" height="15" fill="rgb(226,27,33)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="431.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (11 samples, 0.03%)</title><rect x="87.0935%" y="405" width="0.0283%" height="15" fill="rgb(213,82,22)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="415.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (11 samples, 0.03%)</title><rect x="87.0935%" y="389" width="0.0283%" height="15" fill="rgb(248,140,0)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (11 samples, 0.03%)</title><rect x="87.0935%" y="373" width="0.0283%" height="15" fill="rgb(228,106,3)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_swap (11 samples, 0.03%)</title><rect x="87.0935%" y="357" width="0.0283%" height="15" fill="rgb(209,23,37)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="367.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (60 samples, 0.15%)</title><rect x="87.1218%" y="437" width="0.1545%" height="15" fill="rgb(241,93,50)" fg:x="33832" fg:w="60"/><text x="87.3718%" y="447.50"></text></g><g><title>EVP_EncryptFinal_ex (60 samples, 0.15%)</title><rect x="87.1218%" y="421" width="0.1545%" height="15" fill="rgb(253,46,43)" fg:x="33832" fg:w="60"/><text x="87.3718%" y="431.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="87.1398%" y="405" width="0.1365%" height="15" fill="rgb(226,206,43)" fg:x="33839" fg:w="53"/><text x="87.3898%" y="415.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="87.1398%" y="389" width="0.1365%" height="15" fill="rgb(217,54,7)" fg:x="33839" fg:w="53"/><text x="87.3898%" y="399.50"></text></g><g><title>[libcrypto.so.3] (48 samples, 0.12%)</title><rect x="87.1527%" y="373" width="0.1236%" height="15" fill="rgb(223,5,52)" fg:x="33844" fg:w="48"/><text x="87.4027%" y="383.50"></text></g><g><title>CRYPTO_gcm128_tag (48 samples, 0.12%)</title><rect x="87.1527%" y="357" width="0.1236%" height="15" fill="rgb(206,52,46)" fg:x="33844" fg:w="48"/><text x="87.4027%" y="367.50"></text></g><g><title>CRYPTO_gcm128_finish (40 samples, 0.10%)</title><rect x="87.1733%" y="341" width="0.1030%" height="15" fill="rgb(253,136,11)" fg:x="33852" fg:w="40"/><text x="87.4233%" y="351.50"></text></g><g><title>[libcrypto.so.3] (26 samples, 0.07%)</title><rect x="87.2093%" y="325" width="0.0670%" height="15" fill="rgb(208,106,33)" fg:x="33866" fg:w="26"/><text x="87.4593%" y="335.50"></text></g><g><title>[libc.so.6] (21 samples, 0.05%)</title><rect x="87.4076%" y="373" width="0.0541%" height="15" fill="rgb(206,54,4)" fg:x="33943" fg:w="21"/><text x="87.6576%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (45 samples, 0.12%)</title><rect x="87.3535%" y="389" width="0.1159%" height="15" fill="rgb(213,3,15)" fg:x="33922" fg:w="45"/><text x="87.6035%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::finish (153 samples, 0.39%)</title><rect x="87.0883%" y="453" width="0.3940%" height="15" fill="rgb(252,211,39)" fg:x="33819" fg:w="153"/><text x="87.3383%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::get_tag (80 samples, 0.21%)</title><rect x="87.2763%" y="437" width="0.2060%" height="15" fill="rgb(223,6,36)" fg:x="33892" fg:w="80"/><text x="87.5263%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (79 samples, 0.20%)</title><rect x="87.2789%" y="421" width="0.2034%" height="15" fill="rgb(252,169,45)" fg:x="33893" fg:w="79"/><text x="87.5289%" y="431.50"></text></g><g><title>[libcrypto.so.3] (55 samples, 0.14%)</title><rect x="87.3407%" y="405" width="0.1416%" height="15" fill="rgb(212,48,26)" fg:x="33917" fg:w="55"/><text x="87.5907%" y="415.50"></text></g><g><title>OSSL_PARAM_set_octet_string (5 samples, 0.01%)</title><rect x="87.4694%" y="389" width="0.0129%" height="15" fill="rgb(251,102,48)" fg:x="33967" fg:w="5"/><text x="87.7194%" y="399.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (13 samples, 0.03%)</title><rect x="87.4823%" y="437" width="0.0335%" height="15" fill="rgb(243,208,16)" fg:x="33972" fg:w="13"/><text x="87.7323%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (13 samples, 0.03%)</title><rect x="87.4823%" y="421" width="0.0335%" height="15" fill="rgb(219,96,24)" fg:x="33972" fg:w="13"/><text x="87.7323%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (13 samples, 0.03%)</title><rect x="87.4823%" y="405" width="0.0335%" height="15" fill="rgb(219,33,29)" fg:x="33972" fg:w="13"/><text x="87.7323%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (13 samples, 0.03%)</title><rect x="87.4823%" y="389" width="0.0335%" height="15" fill="rgb(223,176,5)" fg:x="33972" fg:w="13"/><text x="87.7323%" y="399.50"></text></g><g><title>[libcrypto.so.3] (40 samples, 0.10%)</title><rect x="87.6008%" y="373" width="0.1030%" height="15" fill="rgb(228,140,14)" fg:x="34018" fg:w="40"/><text x="87.8508%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (36 samples, 0.09%)</title><rect x="87.6111%" y="357" width="0.0927%" height="15" fill="rgb(217,179,31)" fg:x="34022" fg:w="36"/><text x="87.8611%" y="367.50"></text></g><g><title>[libc.so.6] (20 samples, 0.05%)</title><rect x="87.6523%" y="341" width="0.0515%" height="15" fill="rgb(230,9,30)" fg:x="34038" fg:w="20"/><text x="87.9023%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (67 samples, 0.17%)</title><rect x="87.5441%" y="389" width="0.1725%" height="15" fill="rgb(230,136,20)" fg:x="33996" fg:w="67"/><text x="87.7941%" y="399.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.7038%" y="373" width="0.0129%" height="15" fill="rgb(215,210,22)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="383.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.7038%" y="357" width="0.0129%" height="15" fill="rgb(218,43,5)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="367.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="87.7038%" y="341" width="0.0129%" height="15" fill="rgb(216,11,5)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="351.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="87.7038%" y="325" width="0.0129%" height="15" fill="rgb(209,82,29)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="335.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="87.7038%" y="309" width="0.0129%" height="15" fill="rgb(244,115,12)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="319.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="87.7038%" y="293" width="0.0129%" height="15" fill="rgb(222,82,18)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="303.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="87.7038%" y="277" width="0.0129%" height="15" fill="rgb(249,227,8)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="287.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="87.7038%" y="261" width="0.0129%" height="15" fill="rgb(253,141,45)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="271.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="87.7038%" y="245" width="0.0129%" height="15" fill="rgb(234,184,4)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="255.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="87.7038%" y="229" width="0.0129%" height="15" fill="rgb(218,194,23)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="239.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="87.7038%" y="213" width="0.0129%" height="15" fill="rgb(235,66,41)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="223.50"></text></g><g><title>[libc.so.6] (17 samples, 0.04%)</title><rect x="87.8171%" y="341" width="0.0438%" height="15" fill="rgb(245,217,1)" fg:x="34102" fg:w="17"/><text x="88.0671%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (31 samples, 0.08%)</title><rect x="87.7939%" y="357" width="0.0798%" height="15" fill="rgb(229,91,1)" fg:x="34093" fg:w="31"/><text x="88.0439%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="87.8608%" y="341" width="0.0129%" height="15" fill="rgb(207,101,30)" fg:x="34119" fg:w="5"/><text x="88.1108%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (67 samples, 0.17%)</title><rect x="87.7166%" y="389" width="0.1725%" height="15" fill="rgb(223,82,49)" fg:x="34063" fg:w="67"/><text x="87.9666%" y="399.50"></text></g><g><title>[libcrypto.so.3] (49 samples, 0.13%)</title><rect x="87.7630%" y="373" width="0.1262%" height="15" fill="rgb(218,167,17)" fg:x="34081" fg:w="49"/><text x="88.0130%" y="383.50"></text></g><g><title>OSSL_PARAM_locate_const (6 samples, 0.02%)</title><rect x="87.8737%" y="357" width="0.0155%" height="15" fill="rgb(208,103,14)" fg:x="34124" fg:w="6"/><text x="88.1237%" y="367.50"></text></g><g><title>EVP_CIPHER_free (21 samples, 0.05%)</title><rect x="87.8892%" y="389" width="0.0541%" height="15" fill="rgb(238,20,8)" fg:x="34130" fg:w="21"/><text x="88.1392%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (206 samples, 0.53%)</title><rect x="87.4823%" y="453" width="0.5305%" height="15" fill="rgb(218,80,54)" fg:x="33972" fg:w="206"/><text x="87.7323%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (193 samples, 0.50%)</title><rect x="87.5158%" y="437" width="0.4970%" height="15" fill="rgb(240,144,17)" fg:x="33985" fg:w="193"/><text x="87.7658%" y="447.50"></text></g><g><title>EVP_CipherInit_ex (193 samples, 0.50%)</title><rect x="87.5158%" y="421" width="0.4970%" height="15" fill="rgb(245,27,50)" fg:x="33985" fg:w="193"/><text x="87.7658%" y="431.50"></text></g><g><title>[libcrypto.so.3] (193 samples, 0.50%)</title><rect x="87.5158%" y="405" width="0.4970%" height="15" fill="rgb(251,51,7)" fg:x="33985" fg:w="193"/><text x="87.7658%" y="415.50"></text></g><g><title>EVP_CIPHER_up_ref (27 samples, 0.07%)</title><rect x="87.9432%" y="389" width="0.0695%" height="15" fill="rgb(245,217,29)" fg:x="34151" fg:w="27"/><text x="88.1932%" y="399.50"></text></g><g><title>__rdl_alloc (6 samples, 0.02%)</title><rect x="88.0179%" y="277" width="0.0155%" height="15" fill="rgb(221,176,29)" fg:x="34180" fg:w="6"/><text x="88.2679%" y="287.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::alloc (6 samples, 0.02%)</title><rect x="88.0179%" y="261" width="0.0155%" height="15" fill="rgb(212,180,24)" fg:x="34180" fg:w="6"/><text x="88.2679%" y="271.50"></text></g><g><title>[libc.so.6] (60 samples, 0.15%)</title><rect x="92.2360%" y="245" width="0.1545%" height="15" fill="rgb(254,24,2)" fg:x="35818" fg:w="60"/><text x="92.4860%" y="255.50"></text></g><g><title>[libc.so.6] (978 samples, 2.52%)</title><rect x="89.8875%" y="261" width="2.5185%" height="15" fill="rgb(230,100,2)" fg:x="34906" fg:w="978"/><text x="90.1375%" y="271.50">[l..</text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="92.3931%" y="245" width="0.0129%" height="15" fill="rgb(219,142,25)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="255.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="92.3931%" y="229" width="0.0129%" height="15" fill="rgb(240,73,43)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="239.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="92.3931%" y="213" width="0.0129%" height="15" fill="rgb(214,114,15)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="223.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="92.3931%" y="197" width="0.0129%" height="15" fill="rgb(207,130,4)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="92.3931%" y="181" width="0.0129%" height="15" fill="rgb(221,25,40)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="191.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="92.3931%" y="165" width="0.0129%" height="15" fill="rgb(241,184,7)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="175.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="92.3931%" y="149" width="0.0129%" height="15" fill="rgb(235,159,4)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="159.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="92.3931%" y="133" width="0.0129%" height="15" fill="rgb(214,87,48)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="92.3931%" y="117" width="0.0129%" height="15" fill="rgb(246,198,24)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="92.3931%" y="101" width="0.0129%" height="15" fill="rgb(209,66,40)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="111.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="92.3931%" y="85" width="0.0129%" height="15" fill="rgb(233,147,39)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="95.50"></text></g><g><title>__entry_text_start (4 samples, 0.01%)</title><rect x="92.4497%" y="245" width="0.0103%" height="15" fill="rgb(231,145,52)" fg:x="35901" fg:w="4"/><text x="92.6997%" y="255.50"></text></g><g><title>__get_user_nocheck_4 (14 samples, 0.04%)</title><rect x="92.4703%" y="149" width="0.0361%" height="15" fill="rgb(206,20,26)" fg:x="35909" fg:w="14"/><text x="92.7203%" y="159.50"></text></g><g><title>futex_q_lock (5 samples, 0.01%)</title><rect x="92.5167%" y="149" width="0.0129%" height="15" fill="rgb(238,220,4)" fg:x="35927" fg:w="5"/><text x="92.7667%" y="159.50"></text></g><g><title>futex_q_unlock (17 samples, 0.04%)</title><rect x="92.5295%" y="149" width="0.0438%" height="15" fill="rgb(252,195,42)" fg:x="35932" fg:w="17"/><text x="92.7795%" y="159.50"></text></g><g><title>futex_wait (45 samples, 0.12%)</title><rect x="92.4600%" y="181" width="0.1159%" height="15" fill="rgb(209,10,6)" fg:x="35905" fg:w="45"/><text x="92.7100%" y="191.50"></text></g><g><title>futex_wait_setup (42 samples, 0.11%)</title><rect x="92.4677%" y="165" width="0.1082%" height="15" fill="rgb(229,3,52)" fg:x="35908" fg:w="42"/><text x="92.7177%" y="175.50"></text></g><g><title>do_futex (46 samples, 0.12%)</title><rect x="92.4600%" y="197" width="0.1185%" height="15" fill="rgb(253,49,37)" fg:x="35905" fg:w="46"/><text x="92.7100%" y="207.50"></text></g><g><title>__x64_sys_futex (47 samples, 0.12%)</title><rect x="92.4600%" y="213" width="0.1210%" height="15" fill="rgb(240,103,49)" fg:x="35905" fg:w="47"/><text x="92.7100%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (52 samples, 0.13%)</title><rect x="92.4600%" y="245" width="0.1339%" height="15" fill="rgb(250,182,30)" fg:x="35905" fg:w="52"/><text x="92.7100%" y="255.50"></text></g><g><title>do_syscall_64 (52 samples, 0.13%)</title><rect x="92.4600%" y="229" width="0.1339%" height="15" fill="rgb(248,8,30)" fg:x="35905" fg:w="52"/><text x="92.7100%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (5 samples, 0.01%)</title><rect x="92.5811%" y="213" width="0.0129%" height="15" fill="rgb(237,120,30)" fg:x="35952" fg:w="5"/><text x="92.8311%" y="223.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="92.5811%" y="197" width="0.0129%" height="15" fill="rgb(221,146,34)" fg:x="35952" fg:w="5"/><text x="92.8311%" y="207.50"></text></g><g><title>__lll_lock_wait_private (74 samples, 0.19%)</title><rect x="92.4059%" y="261" width="0.1906%" height="15" fill="rgb(242,55,13)" fg:x="35884" fg:w="74"/><text x="92.6559%" y="271.50"></text></g><g><title>__entry_text_start (10 samples, 0.03%)</title><rect x="92.6068%" y="245" width="0.0258%" height="15" fill="rgb(242,112,31)" fg:x="35962" fg:w="10"/><text x="92.8568%" y="255.50"></text></g><g><title>futex_hash (7 samples, 0.02%)</title><rect x="92.6506%" y="181" width="0.0180%" height="15" fill="rgb(249,192,27)" fg:x="35979" fg:w="7"/><text x="92.9006%" y="191.50"></text></g><g><title>_raw_spin_lock (8 samples, 0.02%)</title><rect x="92.7587%" y="165" width="0.0206%" height="15" fill="rgb(208,204,44)" fg:x="36021" fg:w="8"/><text x="93.0087%" y="175.50"></text></g><g><title>native_queued_spin_lock_slowpath (8 samples, 0.02%)</title><rect x="92.7587%" y="149" width="0.0206%" height="15" fill="rgb(208,93,54)" fg:x="36021" fg:w="8"/><text x="93.0087%" y="159.50"></text></g><g><title>futex_wake_mark (10 samples, 0.03%)</title><rect x="92.7819%" y="165" width="0.0258%" height="15" fill="rgb(242,1,31)" fg:x="36030" fg:w="10"/><text x="93.0319%" y="175.50"></text></g><g><title>wake_q_add_safe (4 samples, 0.01%)</title><rect x="92.8128%" y="165" width="0.0103%" height="15" fill="rgb(241,83,25)" fg:x="36042" fg:w="4"/><text x="93.0628%" y="175.50"></text></g><g><title>__smp_call_single_queue (12 samples, 0.03%)</title><rect x="92.9750%" y="117" width="0.0309%" height="15" fill="rgb(205,169,50)" fg:x="36105" fg:w="12"/><text x="93.2250%" y="127.50"></text></g><g><title>native_send_call_func_single_ipi (8 samples, 0.02%)</title><rect x="92.9853%" y="101" width="0.0206%" height="15" fill="rgb(239,186,37)" fg:x="36109" fg:w="8"/><text x="93.2353%" y="111.50"></text></g><g><title>x2apic_send_IPI (7 samples, 0.02%)</title><rect x="92.9879%" y="85" width="0.0180%" height="15" fill="rgb(205,221,10)" fg:x="36110" fg:w="7"/><text x="93.2379%" y="95.50"></text></g><g><title>native_write_msr (5 samples, 0.01%)</title><rect x="92.9931%" y="69" width="0.0129%" height="15" fill="rgb(218,196,15)" fg:x="36112" fg:w="5"/><text x="93.2431%" y="79.50"></text></g><g><title>llist_add_batch (10 samples, 0.03%)</title><rect x="93.0059%" y="117" width="0.0258%" height="15" fill="rgb(218,196,35)" fg:x="36117" fg:w="10"/><text x="93.2559%" y="127.50"></text></g><g><title>try_to_wake_up (77 samples, 0.20%)</title><rect x="92.8411%" y="149" width="0.1983%" height="15" fill="rgb(233,63,24)" fg:x="36053" fg:w="77"/><text x="93.0911%" y="159.50"></text></g><g><title>ttwu_queue_wakelist (37 samples, 0.10%)</title><rect x="92.9441%" y="133" width="0.0953%" height="15" fill="rgb(225,8,4)" fg:x="36093" fg:w="37"/><text x="93.1941%" y="143.50"></text></g><g><title>futex_wake (145 samples, 0.37%)</title><rect x="92.6686%" y="181" width="0.3734%" height="15" fill="rgb(234,105,35)" fg:x="35986" fg:w="145"/><text x="92.9186%" y="191.50"></text></g><g><title>wake_up_q (85 samples, 0.22%)</title><rect x="92.8231%" y="165" width="0.2189%" height="15" fill="rgb(236,21,32)" fg:x="36046" fg:w="85"/><text x="93.0731%" y="175.50"></text></g><g><title>do_futex (158 samples, 0.41%)</title><rect x="92.6403%" y="197" width="0.4069%" height="15" fill="rgb(228,109,6)" fg:x="35975" fg:w="158"/><text x="92.8903%" y="207.50"></text></g><g><title>__x64_sys_futex (159 samples, 0.41%)</title><rect x="92.6403%" y="213" width="0.4094%" height="15" fill="rgb(229,215,31)" fg:x="35975" fg:w="159"/><text x="92.8903%" y="223.50"></text></g><g><title>exit_to_user_mode_prepare (6 samples, 0.02%)</title><rect x="93.0626%" y="197" width="0.0155%" height="15" fill="rgb(221,52,54)" fg:x="36139" fg:w="6"/><text x="93.3126%" y="207.50"></text></g><g><title>do_syscall_64 (172 samples, 0.44%)</title><rect x="92.6377%" y="229" width="0.4429%" height="15" fill="rgb(252,129,43)" fg:x="35974" fg:w="172"/><text x="92.8877%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (8 samples, 0.02%)</title><rect x="93.0600%" y="213" width="0.0206%" height="15" fill="rgb(248,183,27)" fg:x="36138" fg:w="8"/><text x="93.3100%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (175 samples, 0.45%)</title><rect x="92.6326%" y="245" width="0.4506%" height="15" fill="rgb(250,0,22)" fg:x="35972" fg:w="175"/><text x="92.8826%" y="255.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (1,972 samples, 5.08%)</title><rect x="88.0128%" y="373" width="5.0782%" height="15" fill="rgb(213,166,10)" fg:x="34178" fg:w="1972"/><text x="88.2628%" y="383.50">alloc:..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (1,972 samples, 5.08%)</title><rect x="88.0128%" y="357" width="5.0782%" height="15" fill="rgb(207,163,36)" fg:x="34178" fg:w="1972"/><text x="88.2628%" y="367.50">alloc:..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (1,972 samples, 5.08%)</title><rect x="88.0128%" y="341" width="5.0782%" height="15" fill="rgb(208,122,22)" fg:x="34178" fg:w="1972"/><text x="88.2628%" y="351.50">alloc:..</text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (1,970 samples, 5.07%)</title><rect x="88.0179%" y="325" width="5.0730%" height="15" fill="rgb(207,104,49)" fg:x="34180" fg:w="1970"/><text x="88.2679%" y="335.50">&lt;alloc..</text></g><g><title>alloc::alloc::Global::alloc_impl (1,970 samples, 5.07%)</title><rect x="88.0179%" y="309" width="5.0730%" height="15" fill="rgb(248,211,50)" fg:x="34180" fg:w="1970"/><text x="88.2679%" y="319.50">alloc:..</text></g><g><title>alloc::alloc::alloc (1,970 samples, 5.07%)</title><rect x="88.0179%" y="293" width="5.0730%" height="15" fill="rgb(217,13,45)" fg:x="34180" fg:w="1970"/><text x="88.2679%" y="303.50">alloc:..</text></g><g><title>malloc (1,962 samples, 5.05%)</title><rect x="88.0385%" y="277" width="5.0524%" height="15" fill="rgb(211,216,49)" fg:x="34188" fg:w="1962"/><text x="88.2885%" y="287.50">malloc</text></g><g><title>__lll_lock_wake_private (192 samples, 0.49%)</title><rect x="92.5965%" y="261" width="0.4944%" height="15" fill="rgb(221,58,53)" fg:x="35958" fg:w="192"/><text x="92.8465%" y="271.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (2,175 samples, 5.60%)</title><rect x="88.0128%" y="437" width="5.6009%" height="15" fill="rgb(220,112,41)" fg:x="34178" fg:w="2175"/><text x="88.2628%" y="447.50">alloc::..</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (2,175 samples, 5.60%)</title><rect x="88.0128%" y="421" width="5.6009%" height="15" fill="rgb(236,38,28)" fg:x="34178" fg:w="2175"/><text x="88.2628%" y="431.50">alloc::..</text></g><g><title>alloc::slice::hack::to_vec (2,175 samples, 5.60%)</title><rect x="88.0128%" y="405" width="5.6009%" height="15" fill="rgb(227,195,22)" fg:x="34178" fg:w="2175"/><text x="88.2628%" y="415.50">alloc::..</text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (2,175 samples, 5.60%)</title><rect x="88.0128%" y="389" width="5.6009%" height="15" fill="rgb(214,55,33)" fg:x="34178" fg:w="2175"/><text x="88.2628%" y="399.50">&lt;T as a..</text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (203 samples, 0.52%)</title><rect x="93.0909%" y="373" width="0.5228%" height="15" fill="rgb(248,80,13)" fg:x="36150" fg:w="203"/><text x="93.3409%" y="383.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (203 samples, 0.52%)</title><rect x="93.0909%" y="357" width="0.5228%" height="15" fill="rgb(238,52,6)" fg:x="36150" fg:w="203"/><text x="93.3409%" y="367.50"></text></g><g><title>[libc.so.6] (201 samples, 0.52%)</title><rect x="93.0961%" y="341" width="0.5176%" height="15" fill="rgb(224,198,47)" fg:x="36152" fg:w="201"/><text x="93.3461%" y="351.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (118 samples, 0.30%)</title><rect x="97.7339%" y="373" width="0.3039%" height="15" fill="rgb(233,171,20)" fg:x="37953" fg:w="118"/><text x="97.9839%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (118 samples, 0.30%)</title><rect x="97.7339%" y="357" width="0.3039%" height="15" fill="rgb(241,30,25)" fg:x="37953" fg:w="118"/><text x="97.9839%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (183 samples, 0.47%)</title><rect x="97.6618%" y="389" width="0.4712%" height="15" fill="rgb(207,171,38)" fg:x="37925" fg:w="183"/><text x="97.9118%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (37 samples, 0.10%)</title><rect x="98.0378%" y="373" width="0.0953%" height="15" fill="rgb(234,70,1)" fg:x="38071" fg:w="37"/><text x="98.2878%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (37 samples, 0.10%)</title><rect x="98.0378%" y="357" width="0.0953%" height="15" fill="rgb(232,178,18)" fg:x="38071" fg:w="37"/><text x="98.2878%" y="367.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::write (7 samples, 0.02%)</title><rect x="98.1459%" y="373" width="0.0180%" height="15" fill="rgb(241,78,40)" fg:x="38113" fg:w="7"/><text x="98.3959%" y="383.50"></text></g><g><title>core::ptr::write (7 samples, 0.02%)</title><rect x="98.1459%" y="357" width="0.0180%" height="15" fill="rgb(222,35,25)" fg:x="38113" fg:w="7"/><text x="98.3959%" y="367.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (3,947 samples, 10.16%)</title><rect x="88.0128%" y="453" width="10.1640%" height="15" fill="rgb(207,92,16)" fg:x="34178" fg:w="3947"/><text x="88.2628%" y="463.50">benchmark::bob_..</text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (1,771 samples, 4.56%)</title><rect x="93.6163%" y="437" width="4.5606%" height="15" fill="rgb(216,59,51)" fg:x="36354" fg:w="1771"/><text x="93.8663%" y="447.50">std::..</text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (1,764 samples, 4.54%)</title><rect x="93.6343%" y="421" width="4.5425%" height="15" fill="rgb(213,80,28)" fg:x="36361" fg:w="1764"/><text x="93.8843%" y="431.50">std::..</text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (219 samples, 0.56%)</title><rect x="97.6129%" y="405" width="0.5640%" height="15" fill="rgb(220,93,7)" fg:x="37906" fg:w="219"/><text x="97.8629%" y="415.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (17 samples, 0.04%)</title><rect x="98.1330%" y="389" width="0.0438%" height="15" fill="rgb(225,24,44)" fg:x="38108" fg:w="17"/><text x="98.3830%" y="399.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (5 samples, 0.01%)</title><rect x="98.1639%" y="373" width="0.0129%" height="15" fill="rgb(243,74,40)" fg:x="38120" fg:w="5"/><text x="98.4139%" y="383.50"></text></g><g><title>core::mem::drop (38 samples, 0.10%)</title><rect x="98.1845%" y="453" width="0.0979%" height="15" fill="rgb(228,39,7)" fg:x="38128" fg:w="38"/><text x="98.4345%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (38 samples, 0.10%)</title><rect x="98.1845%" y="437" width="0.0979%" height="15" fill="rgb(227,79,8)" fg:x="38128" fg:w="38"/><text x="98.4345%" y="447.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (38 samples, 0.10%)</title><rect x="98.1845%" y="421" width="0.0979%" height="15" fill="rgb(236,58,11)" fg:x="38128" fg:w="38"/><text x="98.4345%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (38 samples, 0.10%)</title><rect x="98.1845%" y="405" width="0.0979%" height="15" fill="rgb(249,63,35)" fg:x="38128" fg:w="38"/><text x="98.4345%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (36 samples, 0.09%)</title><rect x="98.1897%" y="389" width="0.0927%" height="15" fill="rgb(252,114,16)" fg:x="38130" fg:w="36"/><text x="98.4397%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_sub (36 samples, 0.09%)</title><rect x="98.1897%" y="373" width="0.0927%" height="15" fill="rgb(254,151,24)" fg:x="38130" fg:w="36"/><text x="98.4397%" y="383.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (10 samples, 0.03%)</title><rect x="98.2824%" y="453" width="0.0258%" height="15" fill="rgb(253,54,39)" fg:x="38166" fg:w="10"/><text x="98.5324%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (10 samples, 0.03%)</title><rect x="98.2824%" y="437" width="0.0258%" height="15" fill="rgb(243,25,45)" fg:x="38166" fg:w="10"/><text x="98.5324%" y="447.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index (6 samples, 0.02%)</title><rect x="98.3081%" y="437" width="0.0155%" height="15" fill="rgb(234,134,9)" fg:x="38176" fg:w="6"/><text x="98.5581%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::Index&lt;I&gt; for [T]&gt;::index (11 samples, 0.03%)</title><rect x="98.3081%" y="453" width="0.0283%" height="15" fill="rgb(227,166,31)" fg:x="38176" fg:w="11"/><text x="98.5581%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index (5 samples, 0.01%)</title><rect x="98.3236%" y="437" width="0.0129%" height="15" fill="rgb(245,143,41)" fg:x="38182" fg:w="5"/><text x="98.5736%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (5 samples, 0.01%)</title><rect x="98.3365%" y="453" width="0.0129%" height="15" fill="rgb(238,181,32)" fg:x="38187" fg:w="5"/><text x="98.5865%" y="463.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (5 samples, 0.01%)</title><rect x="98.3365%" y="437" width="0.0129%" height="15" fill="rgb(224,113,18)" fg:x="38187" fg:w="5"/><text x="98.5865%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (34 samples, 0.09%)</title><rect x="98.3571%" y="421" width="0.0876%" height="15" fill="rgb(240,229,28)" fg:x="38195" fg:w="34"/><text x="98.6071%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (34 samples, 0.09%)</title><rect x="98.3571%" y="405" width="0.0876%" height="15" fill="rgb(250,185,3)" fg:x="38195" fg:w="34"/><text x="98.6071%" y="415.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (38 samples, 0.10%)</title><rect x="98.3493%" y="453" width="0.0979%" height="15" fill="rgb(212,59,25)" fg:x="38192" fg:w="38"/><text x="98.5993%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (38 samples, 0.10%)</title><rect x="98.3493%" y="437" width="0.0979%" height="15" fill="rgb(221,87,20)" fg:x="38192" fg:w="38"/><text x="98.5993%" y="447.50"></text></g><g><title>benchmark::bob_main (17,970 samples, 46.28%)</title><rect x="52.1927%" y="501" width="46.2751%" height="15" fill="rgb(213,74,28)" fg:x="20268" fg:w="17970"/><text x="52.4427%" y="511.50">benchmark::bob_main</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::send (8,668 samples, 22.32%)</title><rect x="76.1466%" y="485" width="22.3212%" height="15" fill="rgb(224,132,34)" fg:x="29570" fg:w="8668"/><text x="76.3966%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::send</text></g><g><title>zssp::zeta::send_payload (8,667 samples, 22.32%)</title><rect x="76.1492%" y="469" width="22.3186%" height="15" fill="rgb(222,101,24)" fg:x="29571" fg:w="8667"/><text x="76.3992%" y="479.50">zssp::zeta::send_payload</text></g><g><title>zssp::zeta::get_counter (8 samples, 0.02%)</title><rect x="98.4472%" y="453" width="0.0206%" height="15" fill="rgb(254,142,4)" fg:x="38230" fg:w="8"/><text x="98.6972%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_add (7 samples, 0.02%)</title><rect x="98.4498%" y="437" width="0.0180%" height="15" fill="rgb(230,229,49)" fg:x="38231" fg:w="7"/><text x="98.6998%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_add (7 samples, 0.02%)</title><rect x="98.4498%" y="421" width="0.0180%" height="15" fill="rgb(238,70,47)" fg:x="38231" fg:w="7"/><text x="98.6998%" y="431.50"></text></g><g><title>cfree (25 samples, 0.06%)</title><rect x="98.4678%" y="501" width="0.0644%" height="15" fill="rgb(231,160,17)" fg:x="38238" fg:w="25"/><text x="98.7178%" y="511.50"></text></g><g><title>clock_gettime (17 samples, 0.04%)</title><rect x="98.5322%" y="501" width="0.0438%" height="15" fill="rgb(218,68,53)" fg:x="38263" fg:w="17"/><text x="98.7822%" y="511.50"></text></g><g><title>core::hash::BuildHasher::hash_one (25 samples, 0.06%)</title><rect x="98.5760%" y="501" width="0.0644%" height="15" fill="rgb(236,111,10)" fg:x="38280" fg:w="25"/><text x="98.8260%" y="511.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (18 samples, 0.05%)</title><rect x="98.5940%" y="485" width="0.0464%" height="15" fill="rgb(224,34,41)" fg:x="38287" fg:w="18"/><text x="98.8440%" y="495.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (4 samples, 0.01%)</title><rect x="98.6403%" y="501" width="0.0103%" height="15" fill="rgb(241,118,19)" fg:x="38305" fg:w="4"/><text x="98.8903%" y="511.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::unwrap (10 samples, 0.03%)</title><rect x="98.6506%" y="501" width="0.0258%" height="15" fill="rgb(238,129,25)" fg:x="38309" fg:w="10"/><text x="98.9006%" y="511.50"></text></g><g><title>malloc (11 samples, 0.03%)</title><rect x="98.6764%" y="501" width="0.0283%" height="15" fill="rgb(238,22,31)" fg:x="38319" fg:w="11"/><text x="98.9264%" y="511.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (25 samples, 0.06%)</title><rect x="98.7047%" y="501" width="0.0644%" height="15" fill="rgb(222,174,48)" fg:x="38330" fg:w="25"/><text x="98.9547%" y="511.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_deadline (10 samples, 0.03%)</title><rect x="98.7433%" y="485" width="0.0258%" height="15" fill="rgb(206,152,40)" fg:x="38345" fg:w="10"/><text x="98.9933%" y="495.50"></text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (13 samples, 0.03%)</title><rect x="98.7691%" y="501" width="0.0335%" height="15" fill="rgb(218,99,54)" fg:x="38355" fg:w="13"/><text x="99.0191%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv (28 samples, 0.07%)</title><rect x="98.8026%" y="501" width="0.0721%" height="15" fill="rgb(220,174,26)" fg:x="38368" fg:w="28"/><text x="99.0526%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (14 samples, 0.04%)</title><rect x="98.8747%" y="501" width="0.0361%" height="15" fill="rgb(245,116,9)" fg:x="38396" fg:w="14"/><text x="99.1247%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (21 samples, 0.05%)</title><rect x="98.9107%" y="501" width="0.0541%" height="15" fill="rgb(209,72,35)" fg:x="38410" fg:w="21"/><text x="99.1607%" y="511.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (22 samples, 0.06%)</title><rect x="98.9648%" y="501" width="0.0567%" height="15" fill="rgb(226,126,21)" fg:x="38431" fg:w="22"/><text x="99.2148%" y="511.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (22 samples, 0.06%)</title><rect x="99.0215%" y="501" width="0.0567%" height="15" fill="rgb(227,192,1)" fg:x="38453" fg:w="22"/><text x="99.2715%" y="511.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (5 samples, 0.01%)</title><rect x="99.0652%" y="485" width="0.0129%" height="15" fill="rgb(237,180,29)" fg:x="38470" fg:w="5"/><text x="99.3152%" y="495.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="99.0652%" y="469" width="0.0129%" height="15" fill="rgb(230,197,35)" fg:x="38470" fg:w="5"/><text x="99.3152%" y="479.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (9 samples, 0.02%)</title><rect x="99.0807%" y="501" width="0.0232%" height="15" fill="rgb(246,193,31)" fg:x="38476" fg:w="9"/><text x="99.3307%" y="511.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (9 samples, 0.02%)</title><rect x="99.1039%" y="501" width="0.0232%" height="15" fill="rgb(241,36,4)" fg:x="38485" fg:w="9"/><text x="99.3539%" y="511.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (9 samples, 0.02%)</title><rect x="99.1270%" y="501" width="0.0232%" height="15" fill="rgb(241,130,17)" fg:x="38494" fg:w="9"/><text x="99.3770%" y="511.50"></text></g><g><title>std::time::SystemTime::checked_add (7 samples, 0.02%)</title><rect x="99.1502%" y="501" width="0.0180%" height="15" fill="rgb(206,137,32)" fg:x="38503" fg:w="7"/><text x="99.4002%" y="511.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (19 samples, 0.05%)</title><rect x="99.1708%" y="501" width="0.0489%" height="15" fill="rgb(237,228,51)" fg:x="38511" fg:w="19"/><text x="99.4208%" y="511.50"></text></g><g><title>zssp::zeta::from_nonce (8 samples, 0.02%)</title><rect x="99.2197%" y="501" width="0.0206%" height="15" fill="rgb(243,6,42)" fg:x="38530" fg:w="8"/><text x="99.4697%" y="511.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (20 samples, 0.05%)</title><rect x="99.3511%" y="405" width="0.0515%" height="15" fill="rgb(251,74,28)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="415.50"></text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (20 samples, 0.05%)</title><rect x="99.3511%" y="389" width="0.0515%" height="15" fill="rgb(218,20,49)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="399.50"></text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (20 samples, 0.05%)</title><rect x="99.3511%" y="373" width="0.0515%" height="15" fill="rgb(238,28,14)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="383.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (20 samples, 0.05%)</title><rect x="99.3511%" y="357" width="0.0515%" height="15" fill="rgb(229,40,46)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="367.50"></text></g><g><title>alloc::alloc::Global::alloc_impl (20 samples, 0.05%)</title><rect x="99.3511%" y="341" width="0.0515%" height="15" fill="rgb(244,195,20)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="351.50"></text></g><g><title>alloc::alloc::alloc (20 samples, 0.05%)</title><rect x="99.3511%" y="325" width="0.0515%" height="15" fill="rgb(253,56,35)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="335.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (29 samples, 0.07%)</title><rect x="99.3511%" y="469" width="0.0747%" height="15" fill="rgb(210,149,44)" fg:x="38581" fg:w="29"/><text x="99.6011%" y="479.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (29 samples, 0.07%)</title><rect x="99.3511%" y="453" width="0.0747%" height="15" fill="rgb(240,135,12)" fg:x="38581" fg:w="29"/><text x="99.6011%" y="463.50"></text></g><g><title>alloc::slice::hack::to_vec (29 samples, 0.07%)</title><rect x="99.3511%" y="437" width="0.0747%" height="15" fill="rgb(251,24,50)" fg:x="38581" fg:w="29"/><text x="99.6011%" y="447.50"></text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (29 samples, 0.07%)</title><rect x="99.3511%" y="421" width="0.0747%" height="15" fill="rgb(243,200,47)" fg:x="38581" fg:w="29"/><text x="99.6011%" y="431.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (9 samples, 0.02%)</title><rect x="99.4026%" y="405" width="0.0232%" height="15" fill="rgb(224,166,26)" fg:x="38601" fg:w="9"/><text x="99.6526%" y="415.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (9 samples, 0.02%)</title><rect x="99.4026%" y="389" width="0.0232%" height="15" fill="rgb(233,0,47)" fg:x="38601" fg:w="9"/><text x="99.6526%" y="399.50"></text></g><g><title>zssp::zeta::send_payload (76 samples, 0.20%)</title><rect x="99.2429%" y="501" width="0.1957%" height="15" fill="rgb(253,80,5)" fg:x="38539" fg:w="76"/><text x="99.4929%" y="511.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (34 samples, 0.09%)</title><rect x="99.3511%" y="485" width="0.0876%" height="15" fill="rgb(214,133,25)" fg:x="38581" fg:w="34"/><text x="99.6011%" y="495.50"></text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (5 samples, 0.01%)</title><rect x="99.4257%" y="469" width="0.0129%" height="15" fill="rgb(209,27,14)" fg:x="38610" fg:w="5"/><text x="99.6757%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (6 samples, 0.02%)</title><rect x="99.5880%" y="485" width="0.0155%" height="15" fill="rgb(219,102,51)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="495.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (6 samples, 0.02%)</title><rect x="99.5880%" y="469" width="0.0155%" height="15" fill="rgb(237,18,16)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="479.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (6 samples, 0.02%)</title><rect x="99.5880%" y="453" width="0.0155%" height="15" fill="rgb(241,85,17)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (6 samples, 0.02%)</title><rect x="99.5880%" y="437" width="0.0155%" height="15" fill="rgb(236,90,42)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (6 samples, 0.02%)</title><rect x="99.5880%" y="421" width="0.0155%" height="15" fill="rgb(249,57,21)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (6 samples, 0.02%)</title><rect x="99.5880%" y="405" width="0.0155%" height="15" fill="rgb(243,12,36)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (6 samples, 0.02%)</title><rect x="99.5880%" y="389" width="0.0155%" height="15" fill="rgb(253,128,47)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="399.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (6 samples, 0.02%)</title><rect x="99.5880%" y="373" width="0.0155%" height="15" fill="rgb(207,33,20)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="383.50"></text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (6 samples, 0.02%)</title><rect x="99.5880%" y="357" width="0.0155%" height="15" fill="rgb(233,215,35)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="367.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (6 samples, 0.02%)</title><rect x="99.5880%" y="341" width="0.0155%" height="15" fill="rgb(249,188,52)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="351.50"></text></g><g><title>alloc::alloc::dealloc (6 samples, 0.02%)</title><rect x="99.5880%" y="325" width="0.0155%" height="15" fill="rgb(225,12,32)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="335.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (5 samples, 0.01%)</title><rect x="99.6086%" y="485" width="0.0129%" height="15" fill="rgb(247,98,14)" fg:x="38681" fg:w="5"/><text x="99.8586%" y="495.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (5 samples, 0.01%)</title><rect x="99.6086%" y="469" width="0.0129%" height="15" fill="rgb(247,219,48)" fg:x="38681" fg:w="5"/><text x="99.8586%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (5 samples, 0.01%)</title><rect x="99.6086%" y="453" width="0.0129%" height="15" fill="rgb(253,60,48)" fg:x="38681" fg:w="5"/><text x="99.8586%" y="463.50"></text></g><g><title>hashbrown::map::make_hash (5 samples, 0.01%)</title><rect x="99.6086%" y="437" width="0.0129%" height="15" fill="rgb(245,15,52)" fg:x="38681" fg:w="5"/><text x="99.8586%" y="447.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (78 samples, 0.20%)</title><rect x="99.4412%" y="501" width="0.2009%" height="15" fill="rgb(220,133,28)" fg:x="38616" fg:w="78"/><text x="99.6912%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (8 samples, 0.02%)</title><rect x="99.6215%" y="485" width="0.0206%" height="15" fill="rgb(217,180,4)" fg:x="38686" fg:w="8"/><text x="99.8715%" y="495.50"></text></g><g><title>[unknown] (37,624 samples, 96.89%)</title><rect x="2.7734%" y="517" width="96.8867%" height="15" fill="rgb(251,24,1)" fg:x="1077" fg:w="37624"/><text x="3.0234%" y="527.50">[unknown]</text></g><g><title>zssp::zssp::parse_fragment_header (7 samples, 0.02%)</title><rect x="99.6421%" y="501" width="0.0180%" height="15" fill="rgb(212,185,49)" fg:x="38694" fg:w="7"/><text x="99.8921%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (24 samples, 0.06%)</title><rect x="99.6601%" y="501" width="0.0618%" height="15" fill="rgb(215,175,22)" fg:x="38701" fg:w="24"/><text x="99.9101%" y="511.50"></text></g><g><title>__bss_start (26 samples, 0.07%)</title><rect x="99.6601%" y="517" width="0.0670%" height="15" fill="rgb(250,205,14)" fg:x="38701" fg:w="26"/><text x="99.9101%" y="527.50"></text></g><g><title>__rust_probestack (6 samples, 0.02%)</title><rect x="99.7270%" y="517" width="0.0155%" height="15" fill="rgb(225,211,22)" fg:x="38727" fg:w="6"/><text x="99.9770%" y="527.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (7 samples, 0.02%)</title><rect x="99.7528%" y="517" width="0.0180%" height="15" fill="rgb(251,179,42)" fg:x="38737" fg:w="7"/><text x="100.0028%" y="527.50"></text></g><g><title>entry_SYSCALL_64_safe_stack (14 samples, 0.04%)</title><rect x="99.7708%" y="517" width="0.0361%" height="15" fill="rgb(208,216,51)" fg:x="38744" fg:w="14"/><text x="100.0208%" y="527.50"></text></g><g><title>ret_from_fork (10 samples, 0.03%)</title><rect x="99.8069%" y="517" width="0.0258%" height="15" fill="rgb(235,36,11)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="527.50"></text></g><g><title>schedule_tail (10 samples, 0.03%)</title><rect x="99.8069%" y="501" width="0.0258%" height="15" fill="rgb(213,189,28)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="511.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="99.8069%" y="485" width="0.0258%" height="15" fill="rgb(227,203,42)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="495.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="99.8069%" y="469" width="0.0258%" height="15" fill="rgb(244,72,36)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="479.50"></text></g><g><title>perf_ctx_enable (10 samples, 0.03%)</title><rect x="99.8069%" y="453" width="0.0258%" height="15" fill="rgb(213,53,17)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9588%" y="501" width="0.0129%" height="15" fill="rgb(207,167,3)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="511.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (5 samples, 0.01%)</title><rect x="99.9588%" y="485" width="0.0129%" height="15" fill="rgb(216,98,30)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="495.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (5 samples, 0.01%)</title><rect x="99.9588%" y="469" width="0.0129%" height="15" fill="rgb(236,123,15)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="479.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (5 samples, 0.01%)</title><rect x="99.9588%" y="453" width="0.0129%" height="15" fill="rgb(248,81,50)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (5 samples, 0.01%)</title><rect x="99.9588%" y="437" width="0.0129%" height="15" fill="rgb(214,120,4)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (5 samples, 0.01%)</title><rect x="99.9588%" y="421" width="0.0129%" height="15" fill="rgb(208,179,34)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9588%" y="405" width="0.0129%" height="15" fill="rgb(227,140,7)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9588%" y="389" width="0.0129%" height="15" fill="rgb(214,22,6)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="399.50"></text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (5 samples, 0.01%)</title><rect x="99.9588%" y="373" width="0.0129%" height="15" fill="rgb(207,137,27)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="383.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (5 samples, 0.01%)</title><rect x="99.9588%" y="357" width="0.0129%" height="15" fill="rgb(210,8,46)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="367.50"></text></g><g><title>alloc::alloc::dealloc (5 samples, 0.01%)</title><rect x="99.9588%" y="341" width="0.0129%" height="15" fill="rgb(240,16,54)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="351.50"></text></g><g><title>benchmark (38,828 samples, 99.99%)</title><rect x="0.0000%" y="533" width="99.9871%" height="15" fill="rgb(211,209,29)" fg:x="0" fg:w="38828"/><text x="0.2500%" y="543.50">benchmark</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (58 samples, 0.15%)</title><rect x="99.8378%" y="517" width="0.1494%" height="15" fill="rgb(226,228,24)" fg:x="38770" fg:w="58"/><text x="100.0878%" y="527.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (6 samples, 0.02%)</title><rect x="99.9717%" y="501" width="0.0155%" height="15" fill="rgb(222,84,9)" fg:x="38822" fg:w="6"/><text x="100.2217%" y="511.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (6 samples, 0.02%)</title><rect x="99.9717%" y="485" width="0.0155%" height="15" fill="rgb(234,203,30)" fg:x="38822" fg:w="6"/><text x="100.2217%" y="495.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (6 samples, 0.02%)</title><rect x="99.9717%" y="469" width="0.0155%" height="15" fill="rgb(238,109,14)" fg:x="38822" fg:w="6"/><text x="100.2217%" y="479.50"></text></g><g><title>hashbrown::map::make_hash (6 samples, 0.02%)</title><rect x="99.9717%" y="453" width="0.0155%" height="15" fill="rgb(233,206,34)" fg:x="38822" fg:w="6"/><text x="100.2217%" y="463.50"></text></g><g><title>all (38,833 samples, 100%)</title><rect x="0.0000%" y="549" width="100.0000%" height="15" fill="rgb(220,167,47)" fg:x="0" fg:w="38833"/><text x="0.2500%" y="559.50"></text></g><g><title>perf-exec (5 samples, 0.01%)</title><rect x="99.9871%" y="533" width="0.0129%" height="15" fill="rgb(238,105,10)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="543.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (5 samples, 0.01%)</title><rect x="99.9871%" y="517" width="0.0129%" height="15" fill="rgb(213,227,17)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="527.50"></text></g><g><title>do_syscall_64 (5 samples, 0.01%)</title><rect x="99.9871%" y="501" width="0.0129%" height="15" fill="rgb(217,132,38)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="511.50"></text></g><g><title>__x64_sys_execve (5 samples, 0.01%)</title><rect x="99.9871%" y="485" width="0.0129%" height="15" fill="rgb(242,146,4)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="495.50"></text></g><g><title>do_execveat_common.isra.0 (5 samples, 0.01%)</title><rect x="99.9871%" y="469" width="0.0129%" height="15" fill="rgb(212,61,9)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="479.50"></text></g><g><title>bprm_execve (5 samples, 0.01%)</title><rect x="99.9871%" y="453" width="0.0129%" height="15" fill="rgb(247,126,22)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="463.50"></text></g><g><title>bprm_execve.part.0 (5 samples, 0.01%)</title><rect x="99.9871%" y="437" width="0.0129%" height="15" fill="rgb(220,196,2)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="447.50"></text></g><g><title>exec_binprm (5 samples, 0.01%)</title><rect x="99.9871%" y="421" width="0.0129%" height="15" fill="rgb(208,46,4)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="431.50"></text></g><g><title>search_binary_handler (5 samples, 0.01%)</title><rect x="99.9871%" y="405" width="0.0129%" height="15" fill="rgb(252,104,46)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="415.50"></text></g><g><title>load_elf_binary (5 samples, 0.01%)</title><rect x="99.9871%" y="389" width="0.0129%" height="15" fill="rgb(237,152,48)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="399.50"></text></g><g><title>begin_new_exec (5 samples, 0.01%)</title><rect x="99.9871%" y="373" width="0.0129%" height="15" fill="rgb(221,59,37)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="383.50"></text></g><g><title>perf_event_exec (5 samples, 0.01%)</title><rect x="99.9871%" y="357" width="0.0129%" height="15" fill="rgb(209,202,51)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="367.50"></text></g><g><title>perf_event_enable_on_exec (4 samples, 0.01%)</title><rect x="99.9897%" y="341" width="0.0103%" height="15" fill="rgb(228,81,30)" fg:x="38829" fg:w="4"/><text x="100.2397%" y="351.50"></text></g><g><title>ctx_resched (4 samples, 0.01%)</title><rect x="99.9897%" y="325" width="0.0103%" height="15" fill="rgb(227,42,39)" fg:x="38829" fg:w="4"/><text x="100.2397%" y="335.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="99.9897%" y="309" width="0.0103%" height="15" fill="rgb(221,26,2)" fg:x="38829" fg:w="4"/><text x="100.2397%" y="319.50"></text></g></svg></svg>
\ No newline at end of file
diff --git a/src/crypto_impl/openssl.rs b/src/crypto_impl/openssl.rs
index 596352f..ce2b25b 100644
--- a/src/crypto_impl/openssl.rs
+++ b/src/crypto_impl/openssl.rs
@@ -1,10 +1,9 @@
 use std::{
     ptr::{self, NonNull},
-    sync::Mutex,
+    sync::{Mutex, MutexGuard},
 };
 
 use openssl_sys::*;
-use zeroize::Zeroizing;
 
 use crate::crypto::*;
 
@@ -150,8 +149,8 @@ impl Aes256Dec for Aes256OpenSSLDec {
     }
 }
 
-pub struct AesGcmOpenSSLEnc(CipherCtx);
-impl AesGcmEncContext for AesGcmOpenSSLEnc {
+pub struct AesGcmOpenSSLEnc<'a>(MutexGuard<'a, CipherCtx>);
+impl<'a> AesGcmEncContext for AesGcmOpenSSLEnc<'a> {
     fn encrypt(&mut self, input: &[u8], output: &mut [u8]) {
         unsafe { assert!(self.0.update::<true>(input, output.as_mut_ptr())) };
     }
@@ -166,8 +165,8 @@ impl AesGcmEncContext for AesGcmOpenSSLEnc {
     }
 }
 
-pub struct AesGcmOpenSSLDec(CipherCtx);
-impl AesGcmDecContext for AesGcmOpenSSLDec {
+pub struct AesGcmOpenSSLDec<'a>(MutexGuard<'a, CipherCtx>);
+impl<'a> AesGcmDecContext for AesGcmOpenSSLDec<'a> {
     fn decrypt_in_place(&mut self, data: &mut [u8]) {
         let p = data.as_mut_ptr();
         unsafe { assert!(self.0.update::<false>(data, p)) };
@@ -179,39 +178,54 @@ impl AesGcmDecContext for AesGcmOpenSSLDec {
 }
 
 pub struct AesGcmOpenSSLPool {
-    enc_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
-    dec_key: Zeroizing<[u8; AES_256_KEY_SIZE]>,
+    enc: [Mutex<CipherCtx>; 8],
+    dec: [Mutex<CipherCtx>; 8],
 }
-impl HighThroughputAesGcmPool for AesGcmOpenSSLPool {
-    type EncContext<'a> = AesGcmOpenSSLEnc;
+unsafe impl Send for AesGcmOpenSSLPool {}
+unsafe impl Sync for AesGcmOpenSSLPool {}
 
-    type DecContext<'a> = AesGcmOpenSSLDec;
+impl HighThroughputAesGcmPool for AesGcmOpenSSLPool {
+    type EncContext<'a> = AesGcmOpenSSLEnc<'a>;
+
+    type DecContext<'a> = AesGcmOpenSSLDec<'a>;
 
     fn new(encrypt_key: &[u8; AES_256_KEY_SIZE], decrypt_key: &[u8; AES_256_KEY_SIZE]) -> Self {
-        AesGcmOpenSSLPool {
-            enc_key: Zeroizing::new(*encrypt_key),
-            dec_key: Zeroizing::new(*decrypt_key),
+        unsafe {
+            AesGcmOpenSSLPool {
+                enc: std::array::from_fn(|_| {
+                    let ctx = CipherCtx::new().unwrap();
+                    let t = openssl_sys::EVP_aes_256_gcm();
+                    assert!(ctx.cipher_init::<true>(t, encrypt_key.as_ptr(), ptr::null()));
+                    openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+                    Mutex::new(ctx)
+                }),
+                dec: std::array::from_fn(|_| {
+                    let ctx = CipherCtx::new().unwrap();
+                    let t = openssl_sys::EVP_aes_256_gcm();
+                    assert!(ctx.cipher_init::<false>(t, decrypt_key.as_ptr(), ptr::null()));
+                    openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+                    Mutex::new(ctx)
+                }),
+            }
         }
     }
 
     fn start_enc<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> AesGcmOpenSSLEnc {
-        let ctx = CipherCtx::new().unwrap();
+        let i = u64::from_be_bytes(nonce[4..].try_into().unwrap());
+        let g = self.enc[(i as usize) % self.enc.len()].lock().unwrap();
         unsafe {
-            let t = openssl_sys::EVP_aes_256_gcm();
-            assert!(ctx.cipher_init::<true>(t, self.enc_key.as_ptr(), nonce.as_ptr()));
-            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+            assert!(g.cipher_init::<true>(ptr::null(), ptr::null(), nonce.as_ptr()));
         }
-        AesGcmOpenSSLEnc(ctx)
+        AesGcmOpenSSLEnc(g)
     }
 
     fn start_dec<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> AesGcmOpenSSLDec {
-        let ctx = CipherCtx::new().unwrap();
+        let i = u64::from_be_bytes(nonce[4..].try_into().unwrap());
+        let g = self.dec[(i as usize) % self.enc.len()].lock().unwrap();
         unsafe {
-            let t = openssl_sys::EVP_aes_256_gcm();
-            assert!(ctx.cipher_init::<false>(t, self.dec_key.as_ptr(), nonce.as_ptr()));
-            openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
+            assert!(g.cipher_init::<false>(ptr::null(), ptr::null(), nonce.as_ptr()));
         }
-        AesGcmOpenSSLDec(ctx)
+        AesGcmOpenSSLDec(g)
     }
 }
 

From c8bee176a26d690f8c2814e3270c2f03ba48aa12 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 17:52:18 -0400
Subject: [PATCH 40/50] removed flamegraph.svg

---
 .gitignore     |   1 +
 flamegraph.svg | 491 -------------------------------------------------
 2 files changed, 1 insertion(+), 491 deletions(-)
 delete mode 100644 flamegraph.svg

diff --git a/.gitignore b/.gitignore
index 68e7d6c..c3a4a94 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 /target
 perf*.data
 perf*.old
+.svg
diff --git a/flamegraph.svg b/flamegraph.svg
deleted file mode 100644
index a00c032..0000000
--- a/flamegraph.svg
+++ /dev/null
@@ -1,491 +0,0 @@
-<?xml version="1.0" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg version="1.1" width="1200" height="598" onload="init(evt)" viewBox="0 0 1200 598" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:fg="http://github.com/jonhoo/inferno"><!--Flame graph stack visualization. See https://github.com/brendangregg/FlameGraph for latest version, and http://www.brendangregg.com/flamegraphs.html for examples.--><!--NOTES: --><defs><linearGradient id="background" y1="0" y2="1" x1="0" x2="0"><stop stop-color="#eeeeee" offset="5%"/><stop stop-color="#eeeeb0" offset="95%"/></linearGradient></defs><style type="text/css">
-text { font-family:monospace; font-size:12px }
-#title { text-anchor:middle; font-size:17px; }
-#matched { text-anchor:end; }
-#search { text-anchor:end; opacity:0.1; cursor:pointer; }
-#search:hover, #search.show { opacity:1; }
-#subtitle { text-anchor:middle; font-color:rgb(160,160,160); }
-#unzoom { cursor:pointer; }
-#frames > *:hover { stroke:black; stroke-width:0.5; cursor:pointer; }
-.hide { display:none; }
-.parent { opacity:0.5; }
-</style><script type="text/ecmascript"><![CDATA[
-        var nametype = 'Function:';
-        var fontsize = 12;
-        var fontwidth = 0.59;
-        var xpad = 10;
-        var inverted = false;
-        var searchcolor = 'rgb(230,0,230)';
-        var fluiddrawing = true;
-        var truncate_text_right = false;
-    ]]><![CDATA["use strict";
-var details, searchbtn, unzoombtn, matchedtxt, svg, searching, frames, known_font_width;
-function init(evt) {
-    details = document.getElementById("details").firstChild;
-    searchbtn = document.getElementById("search");
-    unzoombtn = document.getElementById("unzoom");
-    matchedtxt = document.getElementById("matched");
-    svg = document.getElementsByTagName("svg")[0];
-    frames = document.getElementById("frames");
-    known_font_width = get_monospace_width(frames);
-    total_samples = parseInt(frames.attributes.total_samples.value);
-    searching = 0;
-
-    // Use GET parameters to restore a flamegraph's state.
-    var restore_state = function() {
-        var params = get_params();
-        if (params.x && params.y)
-            zoom(find_group(document.querySelector('[*|x="' + params.x + '"][y="' + params.y + '"]')));
-        if (params.s)
-            search(params.s);
-    };
-
-    if (fluiddrawing) {
-        // Make width dynamic so the SVG fits its parent's width.
-        svg.removeAttribute("width");
-        // Edge requires us to have a viewBox that gets updated with size changes.
-        var isEdge = /Edge\/\d./i.test(navigator.userAgent);
-        if (!isEdge) {
-            svg.removeAttribute("viewBox");
-        }
-        var update_for_width_change = function() {
-            if (isEdge) {
-                svg.attributes.viewBox.value = "0 0 " + svg.width.baseVal.value + " " + svg.height.baseVal.value;
-            }
-
-            // Keep consistent padding on left and right of frames container.
-            frames.attributes.width.value = svg.width.baseVal.value - xpad * 2;
-
-            // Text truncation needs to be adjusted for the current width.
-            update_text_for_elements(frames.children);
-
-            // Keep search elements at a fixed distance from right edge.
-            var svgWidth = svg.width.baseVal.value;
-            searchbtn.attributes.x.value = svgWidth - xpad;
-            matchedtxt.attributes.x.value = svgWidth - xpad;
-        };
-        window.addEventListener('resize', function() {
-            update_for_width_change();
-        });
-        // This needs to be done asynchronously for Safari to work.
-        setTimeout(function() {
-            unzoom();
-            update_for_width_change();
-            restore_state();
-        }, 0);
-    } else {
-        restore_state();
-    }
-}
-// event listeners
-window.addEventListener("click", function(e) {
-    var target = find_group(e.target);
-    if (target) {
-        if (target.nodeName == "a") {
-            if (e.ctrlKey === false) return;
-            e.preventDefault();
-        }
-        if (target.classList.contains("parent")) unzoom();
-        zoom(target);
-
-        // set parameters for zoom state
-        var el = target.querySelector("rect");
-        if (el && el.attributes && el.attributes.y && el.attributes["fg:x"]) {
-            var params = get_params()
-            params.x = el.attributes["fg:x"].value;
-            params.y = el.attributes.y.value;
-            history.replaceState(null, null, parse_params(params));
-        }
-    }
-    else if (e.target.id == "unzoom") {
-        unzoom();
-
-        // remove zoom state
-        var params = get_params();
-        if (params.x) delete params.x;
-        if (params.y) delete params.y;
-        history.replaceState(null, null, parse_params(params));
-    }
-    else if (e.target.id == "search") search_prompt();
-}, false)
-// mouse-over for info
-// show
-window.addEventListener("mouseover", function(e) {
-    var target = find_group(e.target);
-    if (target) details.nodeValue = nametype + " " + g_to_text(target);
-}, false)
-// clear
-window.addEventListener("mouseout", function(e) {
-    var target = find_group(e.target);
-    if (target) details.nodeValue = ' ';
-}, false)
-// ctrl-F for search
-window.addEventListener("keydown",function (e) {
-    if (e.keyCode === 114 || (e.ctrlKey && e.keyCode === 70)) {
-        e.preventDefault();
-        search_prompt();
-    }
-}, false)
-// functions
-function get_params() {
-    var params = {};
-    var paramsarr = window.location.search.substr(1).split('&');
-    for (var i = 0; i < paramsarr.length; ++i) {
-        var tmp = paramsarr[i].split("=");
-        if (!tmp[0] || !tmp[1]) continue;
-        params[tmp[0]]  = decodeURIComponent(tmp[1]);
-    }
-    return params;
-}
-function parse_params(params) {
-    var uri = "?";
-    for (var key in params) {
-        uri += key + '=' + encodeURIComponent(params[key]) + '&';
-    }
-    if (uri.slice(-1) == "&")
-        uri = uri.substring(0, uri.length - 1);
-    if (uri == '?')
-        uri = window.location.href.split('?')[0];
-    return uri;
-}
-function find_child(node, selector) {
-    var children = node.querySelectorAll(selector);
-    if (children.length) return children[0];
-    return;
-}
-function find_group(node) {
-    var parent = node.parentElement;
-    if (!parent) return;
-    if (parent.id == "frames") return node;
-    return find_group(parent);
-}
-function orig_save(e, attr, val) {
-    if (e.attributes["fg:orig_" + attr] != undefined) return;
-    if (e.attributes[attr] == undefined) return;
-    if (val == undefined) val = e.attributes[attr].value;
-    e.setAttribute("fg:orig_" + attr, val);
-}
-function orig_load(e, attr) {
-    if (e.attributes["fg:orig_"+attr] == undefined) return;
-    e.attributes[attr].value = e.attributes["fg:orig_" + attr].value;
-    e.removeAttribute("fg:orig_" + attr);
-}
-function g_to_text(e) {
-    var text = find_child(e, "title").firstChild.nodeValue;
-    return (text)
-}
-function g_to_func(e) {
-    var func = g_to_text(e);
-    // if there's any manipulation we want to do to the function
-    // name before it's searched, do it here before returning.
-    return (func);
-}
-function get_monospace_width(frames) {
-    // Given the id="frames" element, return the width of text characters if
-    // this is a monospace font, otherwise return 0.
-    text = find_child(frames.children[0], "text");
-    originalContent = text.textContent;
-    text.textContent = "!";
-    bangWidth = text.getComputedTextLength();
-    text.textContent = "W";
-    wWidth = text.getComputedTextLength();
-    text.textContent = originalContent;
-    if (bangWidth === wWidth) {
-        return bangWidth;
-    } else {
-        return 0;
-    }
-}
-function update_text_for_elements(elements) {
-    // In order to render quickly in the browser, you want to do one pass of
-    // reading attributes, and one pass of mutating attributes. See
-    // https://web.dev/avoid-large-complex-layouts-and-layout-thrashing/ for details.
-
-    // Fall back to inefficient calculation, if we're variable-width font.
-    // TODO This should be optimized somehow too.
-    if (known_font_width === 0) {
-        for (var i = 0; i < elements.length; i++) {
-            update_text(elements[i]);
-        }
-        return;
-    }
-
-    var textElemNewAttributes = [];
-    for (var i = 0; i < elements.length; i++) {
-        var e = elements[i];
-        var r = find_child(e, "rect");
-        var t = find_child(e, "text");
-        var w = parseFloat(r.attributes.width.value) * frames.attributes.width.value / 100 - 3;
-        var txt = find_child(e, "title").textContent.replace(/\([^(]*\)$/,"");
-        var newX = format_percent((parseFloat(r.attributes.x.value) + (100 * 3 / frames.attributes.width.value)));
-
-        // Smaller than this size won't fit anything
-        if (w < 2 * known_font_width) {
-            textElemNewAttributes.push([newX, ""]);
-            continue;
-        }
-
-        // Fit in full text width
-        if (txt.length * known_font_width < w) {
-            textElemNewAttributes.push([newX, txt]);
-            continue;
-        }
-
-        var substringLength = Math.floor(w / known_font_width) - 2;
-        if (truncate_text_right) {
-            // Truncate the right side of the text.
-            textElemNewAttributes.push([newX, txt.substring(0, substringLength) + ".."]);
-            continue;
-        } else {
-            // Truncate the left side of the text.
-            textElemNewAttributes.push([newX, ".." + txt.substring(txt.length - substringLength, txt.length)]);
-            continue;
-        }
-    }
-
-    console.assert(textElemNewAttributes.length === elements.length, "Resize failed, please file a bug at https://github.com/jonhoo/inferno/");
-
-    // Now that we know new textContent, set it all in one go so we don't refresh a bazillion times.
-    for (var i = 0; i < elements.length; i++) {
-        var e = elements[i];
-        var values = textElemNewAttributes[i];
-        var t = find_child(e, "text");
-        t.attributes.x.value = values[0];
-        t.textContent = values[1];
-    }
-}
-
-function update_text(e) {
-    var r = find_child(e, "rect");
-    var t = find_child(e, "text");
-    var w = parseFloat(r.attributes.width.value) * frames.attributes.width.value / 100 - 3;
-    var txt = find_child(e, "title").textContent.replace(/\([^(]*\)$/,"");
-    t.attributes.x.value = format_percent((parseFloat(r.attributes.x.value) + (100 * 3 / frames.attributes.width.value)));
-
-    // Smaller than this size won't fit anything
-    if (w < 2 * fontsize * fontwidth) {
-        t.textContent = "";
-        return;
-    }
-    t.textContent = txt;
-    // Fit in full text width
-    if (t.getComputedTextLength() < w)
-        return;
-    if (truncate_text_right) {
-        // Truncate the right side of the text.
-        for (var x = txt.length - 2; x > 0; x--) {
-            if (t.getSubStringLength(0, x + 2) <= w) {
-                t.textContent = txt.substring(0, x) + "..";
-                return;
-            }
-        }
-    } else {
-        // Truncate the left side of the text.
-        for (var x = 2; x < txt.length; x++) {
-            if (t.getSubStringLength(x - 2, txt.length) <= w) {
-                t.textContent = ".." + txt.substring(x, txt.length);
-                return;
-            }
-        }
-    }
-    t.textContent = "";
-}
-// zoom
-function zoom_reset(e) {
-    if (e.tagName == "rect") {
-        e.attributes.x.value = format_percent(100 * parseInt(e.attributes["fg:x"].value) / total_samples);
-        e.attributes.width.value = format_percent(100 * parseInt(e.attributes["fg:w"].value) / total_samples);
-    }
-    if (e.childNodes == undefined) return;
-    for(var i = 0, c = e.childNodes; i < c.length; i++) {
-        zoom_reset(c[i]);
-    }
-}
-function zoom_child(e, x, zoomed_width_samples) {
-    if (e.tagName == "text") {
-        var parent_x = parseFloat(find_child(e.parentNode, "rect[x]").attributes.x.value);
-        e.attributes.x.value = format_percent(parent_x + (100 * 3 / frames.attributes.width.value));
-    } else if (e.tagName == "rect") {
-        e.attributes.x.value = format_percent(100 * (parseInt(e.attributes["fg:x"].value) - x) / zoomed_width_samples);
-        e.attributes.width.value = format_percent(100 * parseInt(e.attributes["fg:w"].value) / zoomed_width_samples);
-    }
-    if (e.childNodes == undefined) return;
-    for(var i = 0, c = e.childNodes; i < c.length; i++) {
-        zoom_child(c[i], x, zoomed_width_samples);
-    }
-}
-function zoom_parent(e) {
-    if (e.attributes) {
-        if (e.attributes.x != undefined) {
-            e.attributes.x.value = "0.0%";
-        }
-        if (e.attributes.width != undefined) {
-            e.attributes.width.value = "100.0%";
-        }
-    }
-    if (e.childNodes == undefined) return;
-    for(var i = 0, c = e.childNodes; i < c.length; i++) {
-        zoom_parent(c[i]);
-    }
-}
-function zoom(node) {
-    var attr = find_child(node, "rect").attributes;
-    var width = parseInt(attr["fg:w"].value);
-    var xmin = parseInt(attr["fg:x"].value);
-    var xmax = xmin + width;
-    var ymin = parseFloat(attr.y.value);
-    unzoombtn.classList.remove("hide");
-    var el = frames.children;
-    var to_update_text = [];
-    for (var i = 0; i < el.length; i++) {
-        var e = el[i];
-        var a = find_child(e, "rect").attributes;
-        var ex = parseInt(a["fg:x"].value);
-        var ew = parseInt(a["fg:w"].value);
-        // Is it an ancestor
-        if (!inverted) {
-            var upstack = parseFloat(a.y.value) > ymin;
-        } else {
-            var upstack = parseFloat(a.y.value) < ymin;
-        }
-        if (upstack) {
-            // Direct ancestor
-            if (ex <= xmin && (ex+ew) >= xmax) {
-                e.classList.add("parent");
-                zoom_parent(e);
-                to_update_text.push(e);
-            }
-            // not in current path
-            else
-                e.classList.add("hide");
-        }
-        // Children maybe
-        else {
-            // no common path
-            if (ex < xmin || ex >= xmax) {
-                e.classList.add("hide");
-            }
-            else {
-                zoom_child(e, xmin, width);
-                to_update_text.push(e);
-            }
-        }
-    }
-    update_text_for_elements(to_update_text);
-}
-function unzoom() {
-    unzoombtn.classList.add("hide");
-    var el = frames.children;
-    for(var i = 0; i < el.length; i++) {
-        el[i].classList.remove("parent");
-        el[i].classList.remove("hide");
-        zoom_reset(el[i]);
-    }
-    update_text_for_elements(el);
-}
-// search
-function reset_search() {
-    var el = document.querySelectorAll("#frames rect");
-    for (var i = 0; i < el.length; i++) {
-        orig_load(el[i], "fill")
-    }
-    var params = get_params();
-    delete params.s;
-    history.replaceState(null, null, parse_params(params));
-}
-function search_prompt() {
-    if (!searching) {
-        var term = prompt("Enter a search term (regexp " +
-            "allowed, eg: ^ext4_)", "");
-        if (term != null) {
-            search(term)
-        }
-    } else {
-        reset_search();
-        searching = 0;
-        searchbtn.classList.remove("show");
-        searchbtn.firstChild.nodeValue = "Search"
-        matchedtxt.classList.add("hide");
-        matchedtxt.firstChild.nodeValue = ""
-    }
-}
-function search(term) {
-    var re = new RegExp(term);
-    var el = frames.children;
-    var matches = new Object();
-    var maxwidth = 0;
-    for (var i = 0; i < el.length; i++) {
-        var e = el[i];
-        // Skip over frames which are either not visible, or below the zoomed-to frame
-        if (e.classList.contains("hide") || e.classList.contains("parent")) {
-            continue;
-        }
-        var func = g_to_func(e);
-        var rect = find_child(e, "rect");
-        if (func == null || rect == null)
-            continue;
-        // Save max width. Only works as we have a root frame
-        var w = parseInt(rect.attributes["fg:w"].value);
-        if (w > maxwidth)
-            maxwidth = w;
-        if (func.match(re)) {
-            // highlight
-            var x = parseInt(rect.attributes["fg:x"].value);
-            orig_save(rect, "fill");
-            rect.attributes.fill.value = searchcolor;
-            // remember matches
-            if (matches[x] == undefined) {
-                matches[x] = w;
-            } else {
-                if (w > matches[x]) {
-                    // overwrite with parent
-                    matches[x] = w;
-                }
-            }
-            searching = 1;
-        }
-    }
-    if (!searching)
-        return;
-    var params = get_params();
-    params.s = term;
-    history.replaceState(null, null, parse_params(params));
-
-    searchbtn.classList.add("show");
-    searchbtn.firstChild.nodeValue = "Reset Search";
-    // calculate percent matched, excluding vertical overlap
-    var count = 0;
-    var lastx = -1;
-    var lastw = 0;
-    var keys = Array();
-    for (k in matches) {
-        if (matches.hasOwnProperty(k))
-            keys.push(k);
-    }
-    // sort the matched frames by their x location
-    // ascending, then width descending
-    keys.sort(function(a, b){
-        return a - b;
-    });
-    // Step through frames saving only the biggest bottom-up frames
-    // thanks to the sort order. This relies on the tree property
-    // where children are always smaller than their parents.
-    for (var k in keys) {
-        var x = parseInt(keys[k]);
-        var w = matches[keys[k]];
-        if (x >= lastx + lastw) {
-            count += w;
-            lastx = x;
-            lastw = w;
-        }
-    }
-    // display matched percent
-    matchedtxt.classList.remove("hide");
-    var pct = 100 * count / maxwidth;
-    if (pct != 100) pct = pct.toFixed(1);
-    matchedtxt.firstChild.nodeValue = "Matched: " + pct + "%";
-}
-function format_percent(n) {
-    return n.toFixed(4) + "%";
-}
-]]></script><rect x="0" y="0" width="100%" height="598" fill="url(#background)"/><text id="title" fill="rgb(0,0,0)" x="50.0000%" y="24.00">Flame Graph</text><text id="details" fill="rgb(0,0,0)" x="10" y="581.00"> </text><text id="unzoom" class="hide" fill="rgb(0,0,0)" x="10" y="24.00">Reset Zoom</text><text id="search" fill="rgb(0,0,0)" x="1190" y="24.00">Search</text><text id="matched" fill="rgb(0,0,0)" x="1190" y="581.00"> </text><svg id="frames" x="10" width="1180" total_samples="38833"><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (13 samples, 0.03%)</title><rect x="0.0129%" y="501" width="0.0335%" height="15" fill="rgb(227,0,7)" fg:x="5" fg:w="13"/><text x="0.2629%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (7 samples, 0.02%)</title><rect x="0.0283%" y="485" width="0.0180%" height="15" fill="rgb(217,0,24)" fg:x="11" fg:w="7"/><text x="0.2783%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (28 samples, 0.07%)</title><rect x="0.0464%" y="501" width="0.0721%" height="15" fill="rgb(221,193,54)" fg:x="18" fg:w="28"/><text x="0.2964%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4 samples, 0.01%)</title><rect x="0.1082%" y="485" width="0.0103%" height="15" fill="rgb(248,212,6)" fg:x="42" fg:w="4"/><text x="0.3582%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (68 samples, 0.18%)</title><rect x="0.1185%" y="501" width="0.1751%" height="15" fill="rgb(208,68,35)" fg:x="46" fg:w="68"/><text x="0.3685%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (4 samples, 0.01%)</title><rect x="0.2936%" y="485" width="0.0103%" height="15" fill="rgb(232,128,0)" fg:x="114" fg:w="4"/><text x="0.5436%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (6 samples, 0.02%)</title><rect x="0.2936%" y="501" width="0.0155%" height="15" fill="rgb(207,160,47)" fg:x="114" fg:w="6"/><text x="0.5436%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (102 samples, 0.26%)</title><rect x="0.3090%" y="501" width="0.2627%" height="15" fill="rgb(228,23,34)" fg:x="120" fg:w="102"/><text x="0.5590%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (4 samples, 0.01%)</title><rect x="0.5768%" y="501" width="0.0103%" height="15" fill="rgb(218,30,26)" fg:x="224" fg:w="4"/><text x="0.8268%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (5 samples, 0.01%)</title><rect x="0.5871%" y="501" width="0.0129%" height="15" fill="rgb(220,122,19)" fg:x="228" fg:w="5"/><text x="0.8371%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt (8 samples, 0.02%)</title><rect x="0.6000%" y="501" width="0.0206%" height="15" fill="rgb(250,228,42)" fg:x="233" fg:w="8"/><text x="0.8500%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (22 samples, 0.06%)</title><rect x="0.6206%" y="501" width="0.0567%" height="15" fill="rgb(240,193,28)" fg:x="241" fg:w="22"/><text x="0.8706%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt (17 samples, 0.04%)</title><rect x="0.6773%" y="501" width="0.0438%" height="15" fill="rgb(216,20,37)" fg:x="263" fg:w="17"/><text x="0.9273%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (15 samples, 0.04%)</title><rect x="0.7210%" y="501" width="0.0386%" height="15" fill="rgb(206,188,39)" fg:x="280" fg:w="15"/><text x="0.9710%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (7 samples, 0.02%)</title><rect x="0.7597%" y="501" width="0.0180%" height="15" fill="rgb(217,207,13)" fg:x="295" fg:w="7"/><text x="1.0097%" y="511.50"></text></g><g><title>CRYPTO_gcm128_tag (4 samples, 0.01%)</title><rect x="0.7777%" y="501" width="0.0103%" height="15" fill="rgb(231,73,38)" fg:x="302" fg:w="4"/><text x="1.0277%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (9 samples, 0.02%)</title><rect x="0.7880%" y="501" width="0.0232%" height="15" fill="rgb(225,20,46)" fg:x="306" fg:w="9"/><text x="1.0380%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (14 samples, 0.04%)</title><rect x="0.8163%" y="501" width="0.0361%" height="15" fill="rgb(210,31,41)" fg:x="317" fg:w="14"/><text x="1.0663%" y="511.50"></text></g><g><title>EVP_CIPHER_get_block_size (12 samples, 0.03%)</title><rect x="0.8601%" y="501" width="0.0309%" height="15" fill="rgb(221,200,47)" fg:x="334" fg:w="12"/><text x="1.1101%" y="511.50"></text></g><g><title>EVP_CipherInit_ex (9 samples, 0.02%)</title><rect x="0.9064%" y="501" width="0.0232%" height="15" fill="rgb(226,26,5)" fg:x="352" fg:w="9"/><text x="1.1564%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (13 samples, 0.03%)</title><rect x="0.9296%" y="501" width="0.0335%" height="15" fill="rgb(249,33,26)" fg:x="361" fg:w="13"/><text x="1.1796%" y="511.50"></text></g><g><title>EVP_EncryptFinal_ex (5 samples, 0.01%)</title><rect x="0.9631%" y="501" width="0.0129%" height="15" fill="rgb(235,183,28)" fg:x="374" fg:w="5"/><text x="1.2131%" y="511.50"></text></g><g><title>OSSL_PARAM_locate (103 samples, 0.27%)</title><rect x="0.9914%" y="501" width="0.2652%" height="15" fill="rgb(221,5,38)" fg:x="385" fg:w="103"/><text x="1.2414%" y="511.50"></text></g><g><title>[benchmark] (6 samples, 0.02%)</title><rect x="1.2695%" y="501" width="0.0155%" height="15" fill="rgb(247,18,42)" fg:x="493" fg:w="6"/><text x="1.5195%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (6 samples, 0.02%)</title><rect x="1.2695%" y="485" width="0.0155%" height="15" fill="rgb(241,131,45)" fg:x="493" fg:w="6"/><text x="1.5195%" y="495.50"></text></g><g><title>[libc.so.6] (82 samples, 0.21%)</title><rect x="1.2850%" y="501" width="0.2112%" height="15" fill="rgb(249,31,29)" fg:x="499" fg:w="82"/><text x="1.5350%" y="511.50"></text></g><g><title>[libcrypto.so.3] (124 samples, 0.32%)</title><rect x="1.4962%" y="501" width="0.3193%" height="15" fill="rgb(225,111,53)" fg:x="581" fg:w="124"/><text x="1.7462%" y="511.50"></text></g><g><title>__lll_lock_wake_private (4 samples, 0.01%)</title><rect x="1.8206%" y="501" width="0.0103%" height="15" fill="rgb(238,160,17)" fg:x="707" fg:w="4"/><text x="2.0706%" y="511.50"></text></g><g><title>malloc (13 samples, 0.03%)</title><rect x="1.8464%" y="501" width="0.0335%" height="15" fill="rgb(214,148,48)" fg:x="717" fg:w="13"/><text x="2.0964%" y="511.50"></text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (5 samples, 0.01%)</title><rect x="1.8850%" y="501" width="0.0129%" height="15" fill="rgb(232,36,49)" fg:x="732" fg:w="5"/><text x="2.1350%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (8 samples, 0.02%)</title><rect x="1.9597%" y="485" width="0.0206%" height="15" fill="rgb(209,103,24)" fg:x="761" fg:w="8"/><text x="2.2097%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (14 samples, 0.04%)</title><rect x="1.9803%" y="485" width="0.0361%" height="15" fill="rgb(229,88,8)" fg:x="769" fg:w="14"/><text x="2.2303%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (53 samples, 0.14%)</title><rect x="1.9056%" y="501" width="0.1365%" height="15" fill="rgb(213,181,19)" fg:x="740" fg:w="53"/><text x="2.1556%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (10 samples, 0.03%)</title><rect x="2.0163%" y="485" width="0.0258%" height="15" fill="rgb(254,191,54)" fg:x="783" fg:w="10"/><text x="2.2663%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (8 samples, 0.02%)</title><rect x="2.0421%" y="501" width="0.0206%" height="15" fill="rgb(241,83,37)" fg:x="793" fg:w="8"/><text x="2.2921%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (5 samples, 0.01%)</title><rect x="2.0910%" y="485" width="0.0129%" height="15" fill="rgb(233,36,39)" fg:x="812" fg:w="5"/><text x="2.3410%" y="495.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::try_recv (24 samples, 0.06%)</title><rect x="2.0627%" y="501" width="0.0618%" height="15" fill="rgb(226,3,54)" fg:x="801" fg:w="24"/><text x="2.3127%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (8 samples, 0.02%)</title><rect x="2.1039%" y="485" width="0.0206%" height="15" fill="rgb(245,192,40)" fg:x="817" fg:w="8"/><text x="2.3539%" y="495.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (9 samples, 0.02%)</title><rect x="2.1245%" y="501" width="0.0232%" height="15" fill="rgb(238,167,29)" fg:x="825" fg:w="9"/><text x="2.3745%" y="511.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (13 samples, 0.03%)</title><rect x="2.1477%" y="501" width="0.0335%" height="15" fill="rgb(232,182,51)" fg:x="834" fg:w="13"/><text x="2.3977%" y="511.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (8 samples, 0.02%)</title><rect x="2.1605%" y="485" width="0.0206%" height="15" fill="rgb(231,60,39)" fg:x="839" fg:w="8"/><text x="2.4105%" y="495.50"></text></g><g><title>core::sync::atomic::atomic_load (8 samples, 0.02%)</title><rect x="2.1605%" y="469" width="0.0206%" height="15" fill="rgb(208,69,12)" fg:x="839" fg:w="8"/><text x="2.4105%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (7 samples, 0.02%)</title><rect x="2.1811%" y="501" width="0.0180%" height="15" fill="rgb(235,93,37)" fg:x="847" fg:w="7"/><text x="2.4311%" y="511.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (4 samples, 0.01%)</title><rect x="2.2429%" y="485" width="0.0103%" height="15" fill="rgb(213,116,39)" fg:x="871" fg:w="4"/><text x="2.4929%" y="495.50"></text></g><g><title>std::time::Instant::duration_since (4 samples, 0.01%)</title><rect x="2.2429%" y="469" width="0.0103%" height="15" fill="rgb(222,207,29)" fg:x="871" fg:w="4"/><text x="2.4929%" y="479.50"></text></g><g><title>std::time::Instant::checked_duration_since (4 samples, 0.01%)</title><rect x="2.2429%" y="453" width="0.0103%" height="15" fill="rgb(206,96,30)" fg:x="871" fg:w="4"/><text x="2.4929%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (4 samples, 0.01%)</title><rect x="2.2429%" y="437" width="0.0103%" height="15" fill="rgb(218,138,4)" fg:x="871" fg:w="4"/><text x="2.4929%" y="447.50"></text></g><g><title>std::time::Instant::elapsed (21 samples, 0.05%)</title><rect x="2.2017%" y="501" width="0.0541%" height="15" fill="rgb(250,191,14)" fg:x="855" fg:w="21"/><text x="2.4517%" y="511.50"></text></g><g><title>syscall (12 samples, 0.03%)</title><rect x="2.2558%" y="501" width="0.0309%" height="15" fill="rgb(239,60,40)" fg:x="876" fg:w="12"/><text x="2.5058%" y="511.50"></text></g><g><title>__entry_text_start (10 samples, 0.03%)</title><rect x="2.2610%" y="485" width="0.0258%" height="15" fill="rgb(206,27,48)" fg:x="878" fg:w="10"/><text x="2.5110%" y="495.50"></text></g><g><title>[anon] (912 samples, 2.35%)</title><rect x="0.0052%" y="517" width="2.3485%" height="15" fill="rgb(225,35,8)" fg:x="2" fg:w="912"/><text x="0.2552%" y="527.50">[..</text></g><g><title>zssp::zeta::receive_payload_in_place (23 samples, 0.06%)</title><rect x="2.2944%" y="501" width="0.0592%" height="15" fill="rgb(250,213,24)" fg:x="891" fg:w="23"/><text x="2.5444%" y="511.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (5 samples, 0.01%)</title><rect x="2.3408%" y="485" width="0.0129%" height="15" fill="rgb(247,123,22)" fg:x="909" fg:w="5"/><text x="2.5908%" y="495.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (5 samples, 0.01%)</title><rect x="2.3408%" y="469" width="0.0129%" height="15" fill="rgb(231,138,38)" fg:x="909" fg:w="5"/><text x="2.5908%" y="479.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (5 samples, 0.01%)</title><rect x="2.3408%" y="453" width="0.0129%" height="15" fill="rgb(231,145,46)" fg:x="909" fg:w="5"/><text x="2.5908%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (5 samples, 0.01%)</title><rect x="2.3408%" y="437" width="0.0129%" height="15" fill="rgb(251,118,11)" fg:x="909" fg:w="5"/><text x="2.5908%" y="447.50"></text></g><g><title>[libc.so.6] (6 samples, 0.02%)</title><rect x="2.3537%" y="501" width="0.0155%" height="15" fill="rgb(217,147,25)" fg:x="914" fg:w="6"/><text x="2.6037%" y="511.50"></text></g><g><title>__rust_probestack (5 samples, 0.01%)</title><rect x="2.3691%" y="501" width="0.0129%" height="15" fill="rgb(247,81,37)" fg:x="920" fg:w="5"/><text x="2.6191%" y="511.50"></text></g><g><title>[benchmark] (38 samples, 0.10%)</title><rect x="2.3537%" y="517" width="0.0979%" height="15" fill="rgb(209,12,38)" fg:x="914" fg:w="38"/><text x="2.6037%" y="527.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (22 samples, 0.06%)</title><rect x="2.3949%" y="501" width="0.0567%" height="15" fill="rgb(227,1,9)" fg:x="930" fg:w="22"/><text x="2.6449%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (11 samples, 0.03%)</title><rect x="2.4824%" y="501" width="0.0283%" height="15" fill="rgb(248,47,43)" fg:x="964" fg:w="11"/><text x="2.7324%" y="511.50"></text></g><g><title>[libcrypto.so.3] (93 samples, 0.24%)</title><rect x="2.5185%" y="501" width="0.2395%" height="15" fill="rgb(221,10,30)" fg:x="978" fg:w="93"/><text x="2.7685%" y="511.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (5 samples, 0.01%)</title><rect x="2.7580%" y="501" width="0.0129%" height="15" fill="rgb(210,229,1)" fg:x="1071" fg:w="5"/><text x="3.0080%" y="511.50"></text></g><g><title>[libcrypto.so.3] (123 samples, 0.32%)</title><rect x="2.4567%" y="517" width="0.3167%" height="15" fill="rgb(222,148,37)" fg:x="954" fg:w="123"/><text x="2.7067%" y="527.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (20 samples, 0.05%)</title><rect x="2.7734%" y="501" width="0.0515%" height="15" fill="rgb(234,67,33)" fg:x="1077" fg:w="20"/><text x="3.0234%" y="511.50"></text></g><g><title>&lt;std::sync::mpmc::zero::ZeroToken as core::default::Default&gt;::default (7 samples, 0.02%)</title><rect x="2.8249%" y="501" width="0.0180%" height="15" fill="rgb(247,98,35)" fg:x="1097" fg:w="7"/><text x="3.0749%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (17 samples, 0.04%)</title><rect x="2.8429%" y="501" width="0.0438%" height="15" fill="rgb(247,138,52)" fg:x="1104" fg:w="17"/><text x="3.0929%" y="511.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (14 samples, 0.04%)</title><rect x="2.8867%" y="501" width="0.0361%" height="15" fill="rgb(213,79,30)" fg:x="1121" fg:w="14"/><text x="3.1367%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (14 samples, 0.04%)</title><rect x="2.8867%" y="485" width="0.0361%" height="15" fill="rgb(246,177,23)" fg:x="1121" fg:w="14"/><text x="3.1367%" y="495.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (5 samples, 0.01%)</title><rect x="2.9253%" y="501" width="0.0129%" height="15" fill="rgb(230,62,27)" fg:x="1136" fg:w="5"/><text x="3.1753%" y="511.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (5 samples, 0.01%)</title><rect x="2.9253%" y="485" width="0.0129%" height="15" fill="rgb(216,154,8)" fg:x="1136" fg:w="5"/><text x="3.1753%" y="495.50"></text></g><g><title>CRYPTO_gcm128_decrypt (6 samples, 0.02%)</title><rect x="2.9408%" y="501" width="0.0155%" height="15" fill="rgb(244,35,45)" fg:x="1142" fg:w="6"/><text x="3.1908%" y="511.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (25 samples, 0.06%)</title><rect x="2.9562%" y="501" width="0.0644%" height="15" fill="rgb(251,115,12)" fg:x="1148" fg:w="25"/><text x="3.2062%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt (18 samples, 0.05%)</title><rect x="3.0206%" y="501" width="0.0464%" height="15" fill="rgb(240,54,50)" fg:x="1173" fg:w="18"/><text x="3.2706%" y="511.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (33 samples, 0.08%)</title><rect x="3.0670%" y="501" width="0.0850%" height="15" fill="rgb(233,84,52)" fg:x="1191" fg:w="33"/><text x="3.3170%" y="511.50"></text></g><g><title>CRYPTO_gcm128_finish (4 samples, 0.01%)</title><rect x="3.1520%" y="501" width="0.0103%" height="15" fill="rgb(207,117,47)" fg:x="1224" fg:w="4"/><text x="3.4020%" y="511.50"></text></g><g><title>CRYPTO_gcm128_setiv (4 samples, 0.01%)</title><rect x="3.1623%" y="501" width="0.0103%" height="15" fill="rgb(249,43,39)" fg:x="1228" fg:w="4"/><text x="3.4123%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (16 samples, 0.04%)</title><rect x="3.1829%" y="501" width="0.0412%" height="15" fill="rgb(209,38,44)" fg:x="1236" fg:w="16"/><text x="3.4329%" y="511.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (11 samples, 0.03%)</title><rect x="3.2241%" y="501" width="0.0283%" height="15" fill="rgb(236,212,23)" fg:x="1252" fg:w="11"/><text x="3.4741%" y="511.50"></text></g><g><title>EVP_CIPHER_get_block_size (4 samples, 0.01%)</title><rect x="3.2550%" y="501" width="0.0103%" height="15" fill="rgb(242,79,21)" fg:x="1264" fg:w="4"/><text x="3.5050%" y="511.50"></text></g><g><title>EVP_CipherInit_ex (4 samples, 0.01%)</title><rect x="3.2653%" y="501" width="0.0103%" height="15" fill="rgb(211,96,35)" fg:x="1268" fg:w="4"/><text x="3.5153%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (46 samples, 0.12%)</title><rect x="3.2781%" y="501" width="0.1185%" height="15" fill="rgb(253,215,40)" fg:x="1273" fg:w="46"/><text x="3.5281%" y="511.50"></text></g><g><title>EVP_EncryptUpdate (45 samples, 0.12%)</title><rect x="3.3966%" y="501" width="0.1159%" height="15" fill="rgb(211,81,21)" fg:x="1319" fg:w="45"/><text x="3.6466%" y="511.50"></text></g><g><title>OSSL_PARAM_locate (33 samples, 0.08%)</title><rect x="3.5125%" y="501" width="0.0850%" height="15" fill="rgb(208,190,38)" fg:x="1364" fg:w="33"/><text x="3.7625%" y="511.50"></text></g><g><title>[[vdso]] (16 samples, 0.04%)</title><rect x="3.6026%" y="501" width="0.0412%" height="15" fill="rgb(235,213,38)" fg:x="1399" fg:w="16"/><text x="3.8526%" y="511.50"></text></g><g><title>[benchmark] (9 samples, 0.02%)</title><rect x="3.6438%" y="501" width="0.0232%" height="15" fill="rgb(237,122,38)" fg:x="1415" fg:w="9"/><text x="3.8938%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (9 samples, 0.02%)</title><rect x="3.6438%" y="485" width="0.0232%" height="15" fill="rgb(244,218,35)" fg:x="1415" fg:w="9"/><text x="3.8938%" y="495.50"></text></g><g><title>[libc.so.6] (73 samples, 0.19%)</title><rect x="3.6670%" y="501" width="0.1880%" height="15" fill="rgb(240,68,47)" fg:x="1424" fg:w="73"/><text x="3.9170%" y="511.50"></text></g><g><title>[libcrypto.so.3] (329 samples, 0.85%)</title><rect x="3.8550%" y="501" width="0.8472%" height="15" fill="rgb(210,16,53)" fg:x="1497" fg:w="329"/><text x="4.1050%" y="511.50"></text></g><g><title>__bss_start (20 samples, 0.05%)</title><rect x="4.7022%" y="501" width="0.0515%" height="15" fill="rgb(235,124,12)" fg:x="1826" fg:w="20"/><text x="4.9522%" y="511.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="4.7022%" y="485" width="0.0515%" height="15" fill="rgb(224,169,11)" fg:x="1826" fg:w="20"/><text x="4.9522%" y="495.50"></text></g><g><title>__lll_lock_wait_private (4 samples, 0.01%)</title><rect x="4.7537%" y="501" width="0.0103%" height="15" fill="rgb(250,166,2)" fg:x="1846" fg:w="4"/><text x="5.0037%" y="511.50"></text></g><g><title>__entry_text_start (35 samples, 0.09%)</title><rect x="5.1142%" y="309" width="0.0901%" height="15" fill="rgb(242,216,29)" fg:x="1986" fg:w="35"/><text x="5.3642%" y="319.50"></text></g><g><title>crng_make_state (5 samples, 0.01%)</title><rect x="5.2636%" y="261" width="0.0129%" height="15" fill="rgb(230,116,27)" fg:x="2044" fg:w="5"/><text x="5.5136%" y="271.50"></text></g><g><title>_copy_to_iter (38 samples, 0.10%)</title><rect x="5.3769%" y="245" width="0.0979%" height="15" fill="rgb(228,99,48)" fg:x="2088" fg:w="38"/><text x="5.6269%" y="255.50"></text></g><g><title>copyout (28 samples, 0.07%)</title><rect x="5.4026%" y="229" width="0.0721%" height="15" fill="rgb(253,11,6)" fg:x="2098" fg:w="28"/><text x="5.6526%" y="239.50"></text></g><g><title>copyout (5 samples, 0.01%)</title><rect x="5.4747%" y="245" width="0.0129%" height="15" fill="rgb(247,143,39)" fg:x="2126" fg:w="5"/><text x="5.7247%" y="255.50"></text></g><g><title>__memcpy (14 samples, 0.04%)</title><rect x="5.5571%" y="229" width="0.0361%" height="15" fill="rgb(236,97,10)" fg:x="2158" fg:w="14"/><text x="5.8071%" y="239.50"></text></g><g><title>chacha_block_generic (267 samples, 0.69%)</title><rect x="5.6859%" y="213" width="0.6876%" height="15" fill="rgb(233,208,19)" fg:x="2208" fg:w="267"/><text x="5.9359%" y="223.50"></text></g><g><title>chacha_permute (242 samples, 0.62%)</title><rect x="5.7503%" y="197" width="0.6232%" height="15" fill="rgb(216,164,2)" fg:x="2233" fg:w="242"/><text x="6.0003%" y="207.50"></text></g><g><title>__x64_sys_getrandom (440 samples, 1.13%)</title><rect x="5.2455%" y="277" width="1.1331%" height="15" fill="rgb(220,129,5)" fg:x="2037" fg:w="440"/><text x="5.4955%" y="287.50"></text></g><g><title>get_random_bytes_user (428 samples, 1.10%)</title><rect x="5.2764%" y="261" width="1.1022%" height="15" fill="rgb(242,17,10)" fg:x="2049" fg:w="428"/><text x="5.5264%" y="271.50"></text></g><g><title>crng_make_state (343 samples, 0.88%)</title><rect x="5.4953%" y="245" width="0.8833%" height="15" fill="rgb(242,107,0)" fg:x="2134" fg:w="343"/><text x="5.7453%" y="255.50"></text></g><g><title>crng_fast_key_erasure (302 samples, 0.78%)</title><rect x="5.6009%" y="229" width="0.7777%" height="15" fill="rgb(251,28,31)" fg:x="2175" fg:w="302"/><text x="5.8509%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (19 samples, 0.05%)</title><rect x="6.4069%" y="261" width="0.0489%" height="15" fill="rgb(233,223,10)" fg:x="2488" fg:w="19"/><text x="6.6569%" y="271.50"></text></g><g><title>do_syscall_64 (474 samples, 1.22%)</title><rect x="5.2430%" y="293" width="1.2206%" height="15" fill="rgb(215,21,27)" fg:x="2036" fg:w="474"/><text x="5.4930%" y="303.50"></text></g><g><title>syscall_exit_to_user_mode (24 samples, 0.06%)</title><rect x="6.4018%" y="277" width="0.0618%" height="15" fill="rgb(232,23,21)" fg:x="2486" fg:w="24"/><text x="6.6518%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (494 samples, 1.27%)</title><rect x="5.2095%" y="309" width="1.2721%" height="15" fill="rgb(244,5,23)" fg:x="2023" fg:w="494"/><text x="5.4595%" y="319.50"></text></g><g><title>syscall_exit_to_user_mode (4 samples, 0.01%)</title><rect x="6.4713%" y="293" width="0.0103%" height="15" fill="rgb(226,81,46)" fg:x="2513" fg:w="4"/><text x="6.7213%" y="303.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::next_u64 (593 samples, 1.53%)</title><rect x="4.9777%" y="485" width="1.5271%" height="15" fill="rgb(247,70,30)" fg:x="1933" fg:w="593"/><text x="5.2277%" y="495.50"></text></g><g><title>rand_core::impls::next_u64_via_fill (593 samples, 1.53%)</title><rect x="4.9777%" y="469" width="1.5271%" height="15" fill="rgb(212,68,19)" fg:x="1933" fg:w="593"/><text x="5.2277%" y="479.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::fill_bytes (593 samples, 1.53%)</title><rect x="4.9777%" y="453" width="1.5271%" height="15" fill="rgb(240,187,13)" fg:x="1933" fg:w="593"/><text x="5.2277%" y="463.50"></text></g><g><title>&lt;rand_core::os::OsRng as rand_core::RngCore&gt;::try_fill_bytes (587 samples, 1.51%)</title><rect x="4.9932%" y="437" width="1.5116%" height="15" fill="rgb(223,113,26)" fg:x="1939" fg:w="587"/><text x="5.2432%" y="447.50"></text></g><g><title>getrandom::getrandom (587 samples, 1.51%)</title><rect x="4.9932%" y="421" width="1.5116%" height="15" fill="rgb(206,192,2)" fg:x="1939" fg:w="587"/><text x="5.2432%" y="431.50"></text></g><g><title>getrandom::getrandom_uninit (587 samples, 1.51%)</title><rect x="4.9932%" y="405" width="1.5116%" height="15" fill="rgb(241,108,4)" fg:x="1939" fg:w="587"/><text x="5.2432%" y="415.50"></text></g><g><title>getrandom::imp::getrandom_inner (586 samples, 1.51%)</title><rect x="4.9958%" y="389" width="1.5090%" height="15" fill="rgb(247,173,49)" fg:x="1940" fg:w="586"/><text x="5.2458%" y="399.50"></text></g><g><title>getrandom::util_libc::sys_fill_exact (583 samples, 1.50%)</title><rect x="5.0035%" y="373" width="1.5013%" height="15" fill="rgb(224,114,35)" fg:x="1943" fg:w="583"/><text x="5.2535%" y="383.50"></text></g><g><title>getrandom::imp::getrandom_inner::_{{closure}} (577 samples, 1.49%)</title><rect x="5.0189%" y="357" width="1.4858%" height="15" fill="rgb(245,159,27)" fg:x="1949" fg:w="577"/><text x="5.2689%" y="367.50"></text></g><g><title>getrandom::imp::getrandom (577 samples, 1.49%)</title><rect x="5.0189%" y="341" width="1.4858%" height="15" fill="rgb(245,172,44)" fg:x="1949" fg:w="577"/><text x="5.2689%" y="351.50"></text></g><g><title>syscall (575 samples, 1.48%)</title><rect x="5.0241%" y="325" width="1.4807%" height="15" fill="rgb(236,23,11)" fg:x="1951" fg:w="575"/><text x="5.2741%" y="335.50"></text></g><g><title>syscall_return_via_sysret (9 samples, 0.02%)</title><rect x="6.4816%" y="309" width="0.0232%" height="15" fill="rgb(205,117,38)" fg:x="2517" fg:w="9"/><text x="6.7316%" y="319.50"></text></g><g><title>[libc.so.6] (20 samples, 0.05%)</title><rect x="6.5048%" y="485" width="0.0515%" height="15" fill="rgb(237,72,25)" fg:x="2526" fg:w="20"/><text x="6.7548%" y="495.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (7 samples, 0.02%)</title><rect x="6.5563%" y="485" width="0.0180%" height="15" fill="rgb(244,70,9)" fg:x="2546" fg:w="7"/><text x="6.8063%" y="495.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (7 samples, 0.02%)</title><rect x="6.5563%" y="469" width="0.0180%" height="15" fill="rgb(217,125,39)" fg:x="2546" fg:w="7"/><text x="6.8063%" y="479.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (7 samples, 0.02%)</title><rect x="6.5563%" y="453" width="0.0180%" height="15" fill="rgb(235,36,10)" fg:x="2546" fg:w="7"/><text x="6.8063%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (12 samples, 0.03%)</title><rect x="6.5872%" y="485" width="0.0309%" height="15" fill="rgb(251,123,47)" fg:x="2558" fg:w="12"/><text x="6.8372%" y="495.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (12 samples, 0.03%)</title><rect x="6.5872%" y="469" width="0.0309%" height="15" fill="rgb(221,13,13)" fg:x="2558" fg:w="12"/><text x="6.8372%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (12 samples, 0.03%)</title><rect x="6.5872%" y="453" width="0.0309%" height="15" fill="rgb(238,131,9)" fg:x="2558" fg:w="12"/><text x="6.8372%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_sub (12 samples, 0.03%)</title><rect x="6.5872%" y="437" width="0.0309%" height="15" fill="rgb(211,50,8)" fg:x="2558" fg:w="12"/><text x="6.8372%" y="447.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (5 samples, 0.01%)</title><rect x="6.6902%" y="437" width="0.0129%" height="15" fill="rgb(245,182,24)" fg:x="2598" fg:w="5"/><text x="6.9402%" y="447.50"></text></g><g><title>_ZN3std4sync4mpmc5array16Channel$LT$T$GT$10start_recv17h7800ca29c64cb868E.llvm.12455019271255371362 (9 samples, 0.02%)</title><rect x="6.7031%" y="437" width="0.0232%" height="15" fill="rgb(242,14,37)" fg:x="2603" fg:w="9"/><text x="6.9531%" y="447.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init (20 samples, 0.05%)</title><rect x="6.7340%" y="421" width="0.0515%" height="15" fill="rgb(246,228,12)" fg:x="2615" fg:w="20"/><text x="6.9840%" y="431.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (25 samples, 0.06%)</title><rect x="6.7340%" y="437" width="0.0644%" height="15" fill="rgb(213,55,15)" fg:x="2615" fg:w="25"/><text x="6.9840%" y="447.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (5 samples, 0.01%)</title><rect x="6.7855%" y="421" width="0.0129%" height="15" fill="rgb(209,9,3)" fg:x="2635" fg:w="5"/><text x="7.0355%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (44 samples, 0.11%)</title><rect x="6.8936%" y="421" width="0.1133%" height="15" fill="rgb(230,59,30)" fg:x="2677" fg:w="44"/><text x="7.1436%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (44 samples, 0.11%)</title><rect x="6.8936%" y="405" width="0.1133%" height="15" fill="rgb(209,121,21)" fg:x="2677" fg:w="44"/><text x="7.1436%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (177 samples, 0.46%)</title><rect x="7.0069%" y="421" width="0.4558%" height="15" fill="rgb(220,109,13)" fg:x="2721" fg:w="177"/><text x="7.2569%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_load (177 samples, 0.46%)</title><rect x="7.0069%" y="405" width="0.4558%" height="15" fill="rgb(232,18,1)" fg:x="2721" fg:w="177"/><text x="7.2569%" y="415.50"></text></g><g><title>core::sync::atomic::fence (10 samples, 0.03%)</title><rect x="7.4627%" y="421" width="0.0258%" height="15" fill="rgb(215,41,42)" fg:x="2898" fg:w="10"/><text x="7.7127%" y="431.50"></text></g><g><title>std::sync::mpsc::Receiver&lt;T&gt;::try_recv (337 samples, 0.87%)</title><rect x="6.6258%" y="485" width="0.8678%" height="15" fill="rgb(224,123,36)" fg:x="2573" fg:w="337"/><text x="6.8758%" y="495.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::try_recv (337 samples, 0.87%)</title><rect x="6.6258%" y="469" width="0.8678%" height="15" fill="rgb(240,125,3)" fg:x="2573" fg:w="337"/><text x="6.8758%" y="479.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::try_recv (326 samples, 0.84%)</title><rect x="6.6541%" y="453" width="0.8395%" height="15" fill="rgb(205,98,50)" fg:x="2584" fg:w="326"/><text x="6.9041%" y="463.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (270 samples, 0.70%)</title><rect x="6.7983%" y="437" width="0.6953%" height="15" fill="rgb(205,185,37)" fg:x="2640" fg:w="270"/><text x="7.0483%" y="447.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (8 samples, 0.02%)</title><rect x="7.4936%" y="469" width="0.0206%" height="15" fill="rgb(238,207,15)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="479.50"></text></g><g><title>std::time::Instant::duration_since (8 samples, 0.02%)</title><rect x="7.4936%" y="453" width="0.0206%" height="15" fill="rgb(213,199,42)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="463.50"></text></g><g><title>std::time::Instant::checked_duration_since (8 samples, 0.02%)</title><rect x="7.4936%" y="437" width="0.0206%" height="15" fill="rgb(235,201,11)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (8 samples, 0.02%)</title><rect x="7.4936%" y="421" width="0.0206%" height="15" fill="rgb(207,46,11)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="431.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (8 samples, 0.02%)</title><rect x="7.4936%" y="405" width="0.0206%" height="15" fill="rgb(241,35,35)" fg:x="2910" fg:w="8"/><text x="7.7436%" y="415.50"></text></g><g><title>[[vdso]] (33 samples, 0.08%)</title><rect x="7.5194%" y="405" width="0.0850%" height="15" fill="rgb(243,32,47)" fg:x="2920" fg:w="33"/><text x="7.7694%" y="415.50"></text></g><g><title>[[vdso]] (19 samples, 0.05%)</title><rect x="7.5554%" y="389" width="0.0489%" height="15" fill="rgb(247,202,23)" fg:x="2934" fg:w="19"/><text x="7.8054%" y="399.50"></text></g><g><title>std::time::Instant::elapsed (44 samples, 0.11%)</title><rect x="7.4936%" y="485" width="0.1133%" height="15" fill="rgb(219,102,11)" fg:x="2910" fg:w="44"/><text x="7.7436%" y="495.50"></text></g><g><title>std::time::Instant::now (36 samples, 0.09%)</title><rect x="7.5142%" y="469" width="0.0927%" height="15" fill="rgb(243,110,44)" fg:x="2918" fg:w="36"/><text x="7.7642%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::Instant::now (36 samples, 0.09%)</title><rect x="7.5142%" y="453" width="0.0927%" height="15" fill="rgb(222,74,54)" fg:x="2918" fg:w="36"/><text x="7.7642%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (35 samples, 0.09%)</title><rect x="7.5168%" y="437" width="0.0901%" height="15" fill="rgb(216,99,12)" fg:x="2919" fg:w="35"/><text x="7.7668%" y="447.50"></text></g><g><title>clock_gettime (35 samples, 0.09%)</title><rect x="7.5168%" y="421" width="0.0901%" height="15" fill="rgb(226,22,26)" fg:x="2919" fg:w="35"/><text x="7.7668%" y="431.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (401 samples, 1.03%)</title><rect x="7.8361%" y="469" width="1.0326%" height="15" fill="rgb(217,163,10)" fg:x="3043" fg:w="401"/><text x="8.0861%" y="479.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (401 samples, 1.03%)</title><rect x="7.8361%" y="453" width="1.0326%" height="15" fill="rgb(213,25,53)" fg:x="3043" fg:w="401"/><text x="8.0861%" y="463.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (401 samples, 1.03%)</title><rect x="7.8361%" y="437" width="1.0326%" height="15" fill="rgb(252,105,26)" fg:x="3043" fg:w="401"/><text x="8.0861%" y="447.50"></text></g><g><title>&lt;core::result::Result&lt;T,E&gt; as core::ops::try_trait::Try&gt;::branch (4 samples, 0.01%)</title><rect x="8.8687%" y="469" width="0.0103%" height="15" fill="rgb(220,39,43)" fg:x="3444" fg:w="4"/><text x="9.1187%" y="479.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (5 samples, 0.01%)</title><rect x="8.8971%" y="421" width="0.0129%" height="15" fill="rgb(229,68,48)" fg:x="3455" fg:w="5"/><text x="9.1471%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (71 samples, 0.18%)</title><rect x="8.8971%" y="453" width="0.1828%" height="15" fill="rgb(252,8,32)" fg:x="3455" fg:w="71"/><text x="9.1471%" y="463.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (71 samples, 0.18%)</title><rect x="8.8971%" y="437" width="0.1828%" height="15" fill="rgb(223,20,43)" fg:x="3455" fg:w="71"/><text x="9.1471%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (64 samples, 0.16%)</title><rect x="8.9151%" y="421" width="0.1648%" height="15" fill="rgb(229,81,49)" fg:x="3462" fg:w="64"/><text x="9.1651%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (60 samples, 0.15%)</title><rect x="8.9254%" y="405" width="0.1545%" height="15" fill="rgb(236,28,36)" fg:x="3466" fg:w="60"/><text x="9.1754%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_swap (60 samples, 0.15%)</title><rect x="8.9254%" y="389" width="0.1545%" height="15" fill="rgb(249,185,26)" fg:x="3466" fg:w="60"/><text x="9.1754%" y="399.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (5 samples, 0.01%)</title><rect x="9.0799%" y="437" width="0.0129%" height="15" fill="rgb(249,174,33)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="447.50"></text></g><g><title>std::sync::poison::Flag::guard (5 samples, 0.01%)</title><rect x="9.0799%" y="421" width="0.0129%" height="15" fill="rgb(233,201,37)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="431.50"></text></g><g><title>std::thread::panicking (5 samples, 0.01%)</title><rect x="9.0799%" y="405" width="0.0129%" height="15" fill="rgb(221,78,26)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="415.50"></text></g><g><title>std::panicking::panicking (5 samples, 0.01%)</title><rect x="9.0799%" y="389" width="0.0129%" height="15" fill="rgb(250,127,30)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="399.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (5 samples, 0.01%)</title><rect x="9.0799%" y="373" width="0.0129%" height="15" fill="rgb(230,49,44)" fg:x="3526" fg:w="5"/><text x="9.3299%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (77 samples, 0.20%)</title><rect x="9.0799%" y="453" width="0.1983%" height="15" fill="rgb(229,67,23)" fg:x="3526" fg:w="77"/><text x="9.3299%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (72 samples, 0.19%)</title><rect x="9.0928%" y="437" width="0.1854%" height="15" fill="rgb(249,83,47)" fg:x="3531" fg:w="72"/><text x="9.3428%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (70 samples, 0.18%)</title><rect x="9.0979%" y="421" width="0.1803%" height="15" fill="rgb(215,43,3)" fg:x="3533" fg:w="70"/><text x="9.3479%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (70 samples, 0.18%)</title><rect x="9.0979%" y="405" width="0.1803%" height="15" fill="rgb(238,154,13)" fg:x="3533" fg:w="70"/><text x="9.3479%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_get_block_size (5 samples, 0.01%)</title><rect x="9.3657%" y="421" width="0.0129%" height="15" fill="rgb(219,56,2)" fg:x="3637" fg:w="5"/><text x="9.6157%" y="431.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (394 samples, 1.01%)</title><rect x="8.8893%" y="469" width="1.0146%" height="15" fill="rgb(233,0,4)" fg:x="3452" fg:w="394"/><text x="9.1393%" y="479.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (243 samples, 0.63%)</title><rect x="9.2782%" y="453" width="0.6258%" height="15" fill="rgb(235,30,7)" fg:x="3603" fg:w="243"/><text x="9.5282%" y="463.50"></text></g><g><title>EVP_DecryptUpdate (242 samples, 0.62%)</title><rect x="9.2808%" y="437" width="0.6232%" height="15" fill="rgb(250,79,13)" fg:x="3604" fg:w="242"/><text x="9.5308%" y="447.50"></text></g><g><title>[libcrypto.so.3] (204 samples, 0.53%)</title><rect x="9.3786%" y="421" width="0.5253%" height="15" fill="rgb(211,146,34)" fg:x="3642" fg:w="204"/><text x="9.6286%" y="431.50"></text></g><g><title>[libcrypto.so.3] (152 samples, 0.39%)</title><rect x="9.5125%" y="405" width="0.3914%" height="15" fill="rgb(228,22,38)" fg:x="3694" fg:w="152"/><text x="9.7625%" y="415.50"></text></g><g><title>[libcrypto.so.3] (144 samples, 0.37%)</title><rect x="9.5331%" y="389" width="0.3708%" height="15" fill="rgb(235,168,5)" fg:x="3702" fg:w="144"/><text x="9.7831%" y="399.50"></text></g><g><title>__rust_probestack (9 samples, 0.02%)</title><rect x="9.9039%" y="469" width="0.0232%" height="15" fill="rgb(221,155,16)" fg:x="3846" fg:w="9"/><text x="10.1539%" y="479.50"></text></g><g><title>core::cmp::Ord::max (4 samples, 0.01%)</title><rect x="9.9323%" y="469" width="0.0103%" height="15" fill="rgb(215,215,53)" fg:x="3857" fg:w="4"/><text x="10.1823%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (4 samples, 0.01%)</title><rect x="9.9323%" y="453" width="0.0103%" height="15" fill="rgb(223,4,10)" fg:x="3857" fg:w="4"/><text x="10.1823%" y="463.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="9.9503%" y="293" width="0.0129%" height="15" fill="rgb(234,103,6)" fg:x="3864" fg:w="5"/><text x="10.2003%" y="303.50"></text></g><g><title>core::num::nonzero::NonZeroU32::new (13 samples, 0.03%)</title><rect x="9.9426%" y="469" width="0.0335%" height="15" fill="rgb(227,97,0)" fg:x="3861" fg:w="13"/><text x="10.1926%" y="479.50"></text></g><g><title>asm_sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="9.9503%" y="453" width="0.0258%" height="15" fill="rgb(234,150,53)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="463.50"></text></g><g><title>sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="9.9503%" y="437" width="0.0258%" height="15" fill="rgb(228,201,54)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="447.50"></text></g><g><title>irqentry_exit (10 samples, 0.03%)</title><rect x="9.9503%" y="421" width="0.0258%" height="15" fill="rgb(222,22,37)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="431.50"></text></g><g><title>irqentry_exit_to_user_mode (10 samples, 0.03%)</title><rect x="9.9503%" y="405" width="0.0258%" height="15" fill="rgb(237,53,32)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="415.50"></text></g><g><title>exit_to_user_mode_prepare (10 samples, 0.03%)</title><rect x="9.9503%" y="389" width="0.0258%" height="15" fill="rgb(233,25,53)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="399.50"></text></g><g><title>exit_to_user_mode_loop (10 samples, 0.03%)</title><rect x="9.9503%" y="373" width="0.0258%" height="15" fill="rgb(210,40,34)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="383.50"></text></g><g><title>schedule (10 samples, 0.03%)</title><rect x="9.9503%" y="357" width="0.0258%" height="15" fill="rgb(241,220,44)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="367.50"></text></g><g><title>__schedule (10 samples, 0.03%)</title><rect x="9.9503%" y="341" width="0.0258%" height="15" fill="rgb(235,28,35)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="351.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="9.9503%" y="325" width="0.0258%" height="15" fill="rgb(210,56,17)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="335.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="9.9503%" y="309" width="0.0258%" height="15" fill="rgb(224,130,29)" fg:x="3864" fg:w="10"/><text x="10.2003%" y="319.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="9.9632%" y="293" width="0.0129%" height="15" fill="rgb(235,212,8)" fg:x="3869" fg:w="5"/><text x="10.2132%" y="303.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade::_{{closure}} (9 samples, 0.02%)</title><rect x="9.9941%" y="405" width="0.0232%" height="15" fill="rgb(223,33,50)" fg:x="3881" fg:w="9"/><text x="10.2441%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (61 samples, 0.16%)</title><rect x="10.0173%" y="405" width="0.1571%" height="15" fill="rgb(219,149,13)" fg:x="3890" fg:w="61"/><text x="10.2673%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (61 samples, 0.16%)</title><rect x="10.0173%" y="389" width="0.1571%" height="15" fill="rgb(250,156,29)" fg:x="3890" fg:w="61"/><text x="10.2673%" y="399.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade (81 samples, 0.21%)</title><rect x="9.9761%" y="437" width="0.2086%" height="15" fill="rgb(216,193,19)" fg:x="3874" fg:w="81"/><text x="10.2261%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_update (78 samples, 0.20%)</title><rect x="9.9838%" y="421" width="0.2009%" height="15" fill="rgb(216,135,14)" fg:x="3877" fg:w="78"/><text x="10.2338%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (4 samples, 0.01%)</title><rect x="10.1743%" y="405" width="0.0103%" height="15" fill="rgb(241,47,5)" fg:x="3951" fg:w="4"/><text x="10.4243%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (4 samples, 0.01%)</title><rect x="10.1743%" y="389" width="0.0103%" height="15" fill="rgb(233,42,35)" fg:x="3951" fg:w="4"/><text x="10.4243%" y="399.50"></text></g><g><title>core::option::Option&lt;T&gt;::map (82 samples, 0.21%)</title><rect x="9.9761%" y="469" width="0.2112%" height="15" fill="rgb(231,13,6)" fg:x="3874" fg:w="82"/><text x="10.2261%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive::_{{closure}} (82 samples, 0.21%)</title><rect x="9.9761%" y="453" width="0.2112%" height="15" fill="rgb(207,181,40)" fg:x="3874" fg:w="82"/><text x="10.2261%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (55 samples, 0.14%)</title><rect x="10.1872%" y="469" width="0.1416%" height="15" fill="rgb(254,173,49)" fg:x="3956" fg:w="55"/><text x="10.4372%" y="479.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (55 samples, 0.14%)</title><rect x="10.1872%" y="453" width="0.1416%" height="15" fill="rgb(221,1,38)" fg:x="3956" fg:w="55"/><text x="10.4372%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (53 samples, 0.14%)</title><rect x="10.1924%" y="437" width="0.1365%" height="15" fill="rgb(206,124,46)" fg:x="3958" fg:w="53"/><text x="10.4424%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_sub (53 samples, 0.14%)</title><rect x="10.1924%" y="421" width="0.1365%" height="15" fill="rgb(249,21,11)" fg:x="3958" fg:w="53"/><text x="10.4424%" y="431.50"></text></g><g><title>__rdl_dealloc (4 samples, 0.01%)</title><rect x="10.3494%" y="293" width="0.0103%" height="15" fill="rgb(222,201,40)" fg:x="4019" fg:w="4"/><text x="10.5994%" y="303.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::dealloc (4 samples, 0.01%)</title><rect x="10.3494%" y="277" width="0.0103%" height="15" fill="rgb(235,61,29)" fg:x="4019" fg:w="4"/><text x="10.5994%" y="287.50"></text></g><g><title>__rust_dealloc (5 samples, 0.01%)</title><rect x="10.3597%" y="293" width="0.0129%" height="15" fill="rgb(219,207,3)" fg:x="4023" fg:w="5"/><text x="10.6097%" y="303.50"></text></g><g><title>[libc.so.6] (48 samples, 0.12%)</title><rect x="11.5134%" y="261" width="0.1236%" height="15" fill="rgb(222,56,46)" fg:x="4471" fg:w="48"/><text x="11.7634%" y="271.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="11.6241%" y="245" width="0.0129%" height="15" fill="rgb(239,76,54)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="255.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="11.6241%" y="229" width="0.0129%" height="15" fill="rgb(231,124,27)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="239.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="11.6241%" y="213" width="0.0129%" height="15" fill="rgb(249,195,6)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="223.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="11.6241%" y="197" width="0.0129%" height="15" fill="rgb(237,174,47)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="11.6241%" y="181" width="0.0129%" height="15" fill="rgb(206,201,31)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="191.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="11.6241%" y="165" width="0.0129%" height="15" fill="rgb(231,57,52)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="175.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="11.6241%" y="149" width="0.0129%" height="15" fill="rgb(248,177,22)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="159.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="11.6241%" y="133" width="0.0129%" height="15" fill="rgb(215,211,37)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="11.6241%" y="117" width="0.0129%" height="15" fill="rgb(241,128,51)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="11.6241%" y="101" width="0.0129%" height="15" fill="rgb(227,165,31)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="111.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="11.6241%" y="85" width="0.0129%" height="15" fill="rgb(228,167,24)" fg:x="4514" fg:w="5"/><text x="11.8741%" y="95.50"></text></g><g><title>__entry_text_start (14 samples, 0.04%)</title><rect x="11.7503%" y="245" width="0.0361%" height="15" fill="rgb(228,143,12)" fg:x="4563" fg:w="14"/><text x="12.0003%" y="255.50"></text></g><g><title>futex_unqueue (10 samples, 0.03%)</title><rect x="11.8662%" y="165" width="0.0258%" height="15" fill="rgb(249,149,8)" fg:x="4608" fg:w="10"/><text x="12.1162%" y="175.50"></text></g><g><title>update_curr (11 samples, 0.03%)</title><rect x="12.0104%" y="69" width="0.0283%" height="15" fill="rgb(243,35,44)" fg:x="4664" fg:w="11"/><text x="12.2604%" y="79.50"></text></g><g><title>cpuacct_charge (5 samples, 0.01%)</title><rect x="12.0259%" y="53" width="0.0129%" height="15" fill="rgb(246,89,9)" fg:x="4670" fg:w="5"/><text x="12.2759%" y="63.50"></text></g><g><title>update_load_avg (8 samples, 0.02%)</title><rect x="12.0387%" y="69" width="0.0206%" height="15" fill="rgb(233,213,13)" fg:x="4675" fg:w="8"/><text x="12.2887%" y="79.50"></text></g><g><title>dequeue_entity (28 samples, 0.07%)</title><rect x="11.9898%" y="85" width="0.0721%" height="15" fill="rgb(233,141,41)" fg:x="4656" fg:w="28"/><text x="12.2398%" y="95.50"></text></g><g><title>dequeue_task (37 samples, 0.10%)</title><rect x="11.9744%" y="117" width="0.0953%" height="15" fill="rgb(239,167,4)" fg:x="4650" fg:w="37"/><text x="12.2244%" y="127.50"></text></g><g><title>dequeue_task_fair (36 samples, 0.09%)</title><rect x="11.9769%" y="101" width="0.0927%" height="15" fill="rgb(209,217,16)" fg:x="4651" fg:w="36"/><text x="12.2269%" y="111.50"></text></g><g><title>__perf_event_task_sched_in (8 samples, 0.02%)</title><rect x="12.0722%" y="101" width="0.0206%" height="15" fill="rgb(219,88,35)" fg:x="4688" fg:w="8"/><text x="12.3222%" y="111.50"></text></g><g><title>perf_ctx_enable (8 samples, 0.02%)</title><rect x="12.0722%" y="85" width="0.0206%" height="15" fill="rgb(220,193,23)" fg:x="4688" fg:w="8"/><text x="12.3222%" y="95.50"></text></g><g><title>finish_task_switch.isra.0 (18 samples, 0.05%)</title><rect x="12.0696%" y="117" width="0.0464%" height="15" fill="rgb(230,90,52)" fg:x="4687" fg:w="18"/><text x="12.3196%" y="127.50"></text></g><g><title>raw_spin_rq_unlock (9 samples, 0.02%)</title><rect x="12.0928%" y="101" width="0.0232%" height="15" fill="rgb(252,106,19)" fg:x="4696" fg:w="9"/><text x="12.3428%" y="111.50"></text></g><g><title>pick_next_task_fair (4 samples, 0.01%)</title><rect x="12.1237%" y="101" width="0.0103%" height="15" fill="rgb(206,74,20)" fg:x="4708" fg:w="4"/><text x="12.3737%" y="111.50"></text></g><g><title>newidle_balance (4 samples, 0.01%)</title><rect x="12.1237%" y="85" width="0.0103%" height="15" fill="rgb(230,138,44)" fg:x="4708" fg:w="4"/><text x="12.3737%" y="95.50"></text></g><g><title>pick_next_task (11 samples, 0.03%)</title><rect x="12.1160%" y="117" width="0.0283%" height="15" fill="rgb(235,182,43)" fg:x="4705" fg:w="11"/><text x="12.3660%" y="127.50"></text></g><g><title>prepare_task_switch (14 samples, 0.04%)</title><rect x="12.1469%" y="117" width="0.0361%" height="15" fill="rgb(242,16,51)" fg:x="4717" fg:w="14"/><text x="12.3969%" y="127.50"></text></g><g><title>__perf_event_task_sched_out (5 samples, 0.01%)</title><rect x="12.1701%" y="101" width="0.0129%" height="15" fill="rgb(248,9,4)" fg:x="4726" fg:w="5"/><text x="12.4201%" y="111.50"></text></g><g><title>psi_group_change (26 samples, 0.07%)</title><rect x="12.2216%" y="101" width="0.0670%" height="15" fill="rgb(210,31,22)" fg:x="4746" fg:w="26"/><text x="12.4716%" y="111.50"></text></g><g><title>psi_task_switch (44 samples, 0.11%)</title><rect x="12.1881%" y="117" width="0.1133%" height="15" fill="rgb(239,54,39)" fg:x="4733" fg:w="44"/><text x="12.4381%" y="127.50"></text></g><g><title>__schedule (149 samples, 0.38%)</title><rect x="11.9280%" y="133" width="0.3837%" height="15" fill="rgb(230,99,41)" fg:x="4632" fg:w="149"/><text x="12.1780%" y="143.50"></text></g><g><title>futex_wait_queue (165 samples, 0.42%)</title><rect x="11.8919%" y="165" width="0.4249%" height="15" fill="rgb(253,106,12)" fg:x="4618" fg:w="165"/><text x="12.1419%" y="175.50"></text></g><g><title>schedule (159 samples, 0.41%)</title><rect x="11.9074%" y="149" width="0.4094%" height="15" fill="rgb(213,46,41)" fg:x="4624" fg:w="159"/><text x="12.1574%" y="159.50"></text></g><g><title>__get_user_nocheck_4 (16 samples, 0.04%)</title><rect x="12.3297%" y="149" width="0.0412%" height="15" fill="rgb(215,133,35)" fg:x="4788" fg:w="16"/><text x="12.5797%" y="159.50"></text></g><g><title>_raw_spin_lock (5 samples, 0.01%)</title><rect x="12.3709%" y="149" width="0.0129%" height="15" fill="rgb(213,28,5)" fg:x="4804" fg:w="5"/><text x="12.6209%" y="159.50"></text></g><g><title>futex_q_lock (4 samples, 0.01%)</title><rect x="12.3915%" y="149" width="0.0103%" height="15" fill="rgb(215,77,49)" fg:x="4812" fg:w="4"/><text x="12.6415%" y="159.50"></text></g><g><title>futex_q_unlock (7 samples, 0.02%)</title><rect x="12.4018%" y="149" width="0.0180%" height="15" fill="rgb(248,100,22)" fg:x="4816" fg:w="7"/><text x="12.6518%" y="159.50"></text></g><g><title>futex_wait_setup (41 samples, 0.11%)</title><rect x="12.3168%" y="165" width="0.1056%" height="15" fill="rgb(208,67,9)" fg:x="4783" fg:w="41"/><text x="12.5668%" y="175.50"></text></g><g><title>futex_wait (230 samples, 0.59%)</title><rect x="11.8353%" y="181" width="0.5923%" height="15" fill="rgb(219,133,21)" fg:x="4596" fg:w="230"/><text x="12.0853%" y="191.50"></text></g><g><title>do_futex (236 samples, 0.61%)</title><rect x="11.8224%" y="197" width="0.6077%" height="15" fill="rgb(246,46,29)" fg:x="4591" fg:w="236"/><text x="12.0724%" y="207.50"></text></g><g><title>__x64_sys_futex (247 samples, 0.64%)</title><rect x="11.7967%" y="213" width="0.6361%" height="15" fill="rgb(246,185,52)" fg:x="4581" fg:w="247"/><text x="12.0467%" y="223.50"></text></g><g><title>__rseq_handle_notify_resume (7 samples, 0.02%)</title><rect x="12.4817%" y="165" width="0.0180%" height="15" fill="rgb(252,136,11)" fg:x="4847" fg:w="7"/><text x="12.7317%" y="175.50"></text></g><g><title>exit_to_user_mode_loop (21 samples, 0.05%)</title><rect x="12.4559%" y="181" width="0.0541%" height="15" fill="rgb(219,138,53)" fg:x="4837" fg:w="21"/><text x="12.7059%" y="191.50"></text></g><g><title>exit_to_user_mode_prepare (27 samples, 0.07%)</title><rect x="12.4456%" y="197" width="0.0695%" height="15" fill="rgb(211,51,23)" fg:x="4833" fg:w="27"/><text x="12.6956%" y="207.50"></text></g><g><title>do_syscall_64 (283 samples, 0.73%)</title><rect x="11.7941%" y="229" width="0.7288%" height="15" fill="rgb(247,221,28)" fg:x="4580" fg:w="283"/><text x="12.0441%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (31 samples, 0.08%)</title><rect x="12.4430%" y="213" width="0.0798%" height="15" fill="rgb(251,222,45)" fg:x="4832" fg:w="31"/><text x="12.6930%" y="223.50"></text></g><g><title>[libc.so.6] (785 samples, 2.02%)</title><rect x="10.5065%" y="277" width="2.0215%" height="15" fill="rgb(217,162,53)" fg:x="4080" fg:w="785"/><text x="10.7565%" y="287.50">[..</text></g><g><title>__lll_lock_wait_private (346 samples, 0.89%)</title><rect x="11.6370%" y="261" width="0.8910%" height="15" fill="rgb(229,93,14)" fg:x="4519" fg:w="346"/><text x="11.8870%" y="271.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (288 samples, 0.74%)</title><rect x="11.7864%" y="245" width="0.7416%" height="15" fill="rgb(209,67,49)" fg:x="4577" fg:w="288"/><text x="12.0364%" y="255.50"></text></g><g><title>__entry_text_start (13 samples, 0.03%)</title><rect x="12.5383%" y="261" width="0.0335%" height="15" fill="rgb(213,87,29)" fg:x="4869" fg:w="13"/><text x="12.7883%" y="271.50"></text></g><g><title>futex_hash (7 samples, 0.02%)</title><rect x="12.6104%" y="197" width="0.0180%" height="15" fill="rgb(205,151,52)" fg:x="4897" fg:w="7"/><text x="12.8604%" y="207.50"></text></g><g><title>_raw_spin_lock (25 samples, 0.06%)</title><rect x="12.6902%" y="181" width="0.0644%" height="15" fill="rgb(253,215,39)" fg:x="4928" fg:w="25"/><text x="12.9402%" y="191.50"></text></g><g><title>native_queued_spin_lock_slowpath (25 samples, 0.06%)</title><rect x="12.6902%" y="165" width="0.0644%" height="15" fill="rgb(221,220,41)" fg:x="4928" fg:w="25"/><text x="12.9402%" y="175.50"></text></g><g><title>do_futex (66 samples, 0.17%)</title><rect x="12.5975%" y="213" width="0.1700%" height="15" fill="rgb(218,133,21)" fg:x="4892" fg:w="66"/><text x="12.8475%" y="223.50"></text></g><g><title>futex_wake (54 samples, 0.14%)</title><rect x="12.6284%" y="197" width="0.1391%" height="15" fill="rgb(221,193,43)" fg:x="4904" fg:w="54"/><text x="12.8784%" y="207.50"></text></g><g><title>__x64_sys_futex (72 samples, 0.19%)</title><rect x="12.5872%" y="229" width="0.1854%" height="15" fill="rgb(240,128,52)" fg:x="4888" fg:w="72"/><text x="12.8372%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (10 samples, 0.03%)</title><rect x="12.7829%" y="213" width="0.0258%" height="15" fill="rgb(253,114,12)" fg:x="4964" fg:w="10"/><text x="13.0329%" y="223.50"></text></g><g><title>do_syscall_64 (90 samples, 0.23%)</title><rect x="12.5847%" y="245" width="0.2318%" height="15" fill="rgb(215,223,47)" fg:x="4887" fg:w="90"/><text x="12.8347%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (16 samples, 0.04%)</title><rect x="12.7752%" y="229" width="0.0412%" height="15" fill="rgb(248,225,23)" fg:x="4961" fg:w="16"/><text x="13.0252%" y="239.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (98 samples, 0.25%)</title><rect x="12.5744%" y="261" width="0.2524%" height="15" fill="rgb(250,108,0)" fg:x="4883" fg:w="98"/><text x="12.8244%" y="271.50"></text></g><g><title>alloc::alloc::dealloc (965 samples, 2.48%)</title><rect x="10.3494%" y="309" width="2.4850%" height="15" fill="rgb(228,208,7)" fg:x="4019" fg:w="965"/><text x="10.5994%" y="319.50">al..</text></g><g><title>cfree (956 samples, 2.46%)</title><rect x="10.3726%" y="293" width="2.4618%" height="15" fill="rgb(244,45,10)" fg:x="4028" fg:w="956"/><text x="10.6226%" y="303.50">cf..</text></g><g><title>__lll_lock_wake_private (119 samples, 0.31%)</title><rect x="12.5280%" y="277" width="0.3064%" height="15" fill="rgb(207,125,25)" fg:x="4865" fg:w="119"/><text x="12.7780%" y="287.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (970 samples, 2.50%)</title><rect x="10.3494%" y="325" width="2.4979%" height="15" fill="rgb(210,195,18)" fg:x="4019" fg:w="970"/><text x="10.5994%" y="335.50">&lt;a..</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (5 samples, 0.01%)</title><rect x="12.8344%" y="309" width="0.0129%" height="15" fill="rgb(249,80,12)" fg:x="4984" fg:w="5"/><text x="13.0844%" y="319.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (986 samples, 2.54%)</title><rect x="10.3288%" y="469" width="2.5391%" height="15" fill="rgb(221,65,9)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="479.50">co..</text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (986 samples, 2.54%)</title><rect x="10.3288%" y="453" width="2.5391%" height="15" fill="rgb(235,49,36)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="463.50">&lt;a..</text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (986 samples, 2.54%)</title><rect x="10.3288%" y="437" width="2.5391%" height="15" fill="rgb(225,32,20)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="447.50">ar..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (986 samples, 2.54%)</title><rect x="10.3288%" y="421" width="2.5391%" height="15" fill="rgb(215,141,46)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="431.50">ar..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (986 samples, 2.54%)</title><rect x="10.3288%" y="405" width="2.5391%" height="15" fill="rgb(250,160,47)" fg:x="4011" fg:w="986"/><text x="10.5788%" y="415.50">ar..</text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (984 samples, 2.53%)</title><rect x="10.3340%" y="389" width="2.5339%" height="15" fill="rgb(216,222,40)" fg:x="4013" fg:w="984"/><text x="10.5840%" y="399.50">co..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (981 samples, 2.53%)</title><rect x="10.3417%" y="373" width="2.5262%" height="15" fill="rgb(234,217,39)" fg:x="4016" fg:w="981"/><text x="10.5917%" y="383.50">co..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (981 samples, 2.53%)</title><rect x="10.3417%" y="357" width="2.5262%" height="15" fill="rgb(207,178,40)" fg:x="4016" fg:w="981"/><text x="10.5917%" y="367.50">co..</text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (981 samples, 2.53%)</title><rect x="10.3417%" y="341" width="2.5262%" height="15" fill="rgb(221,136,13)" fg:x="4016" fg:w="981"/><text x="10.5917%" y="351.50">&lt;a..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::current_memory (8 samples, 0.02%)</title><rect x="12.8473%" y="325" width="0.0206%" height="15" fill="rgb(249,199,10)" fg:x="4989" fg:w="8"/><text x="13.0973%" y="335.50"></text></g><g><title>core::alloc::layout::Layout::array (6 samples, 0.02%)</title><rect x="12.8525%" y="309" width="0.0155%" height="15" fill="rgb(249,222,13)" fg:x="4991" fg:w="6"/><text x="13.1025%" y="319.50"></text></g><g><title>core::alloc::layout::Layout::array::inner (6 samples, 0.02%)</title><rect x="12.8525%" y="293" width="0.0155%" height="15" fill="rgb(244,185,38)" fg:x="4991" fg:w="6"/><text x="13.1025%" y="303.50"></text></g><g><title>std::sync::poison::Flag::done (10 samples, 0.03%)</title><rect x="12.8679%" y="437" width="0.0258%" height="15" fill="rgb(236,202,9)" fg:x="4997" fg:w="10"/><text x="13.1179%" y="447.50"></text></g><g><title>std::thread::panicking (10 samples, 0.03%)</title><rect x="12.8679%" y="421" width="0.0258%" height="15" fill="rgb(250,229,37)" fg:x="4997" fg:w="10"/><text x="13.1179%" y="431.50"></text></g><g><title>std::panicking::panicking (10 samples, 0.03%)</title><rect x="12.8679%" y="405" width="0.0258%" height="15" fill="rgb(206,174,23)" fg:x="4997" fg:w="10"/><text x="13.1179%" y="415.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (10 samples, 0.03%)</title><rect x="12.8679%" y="389" width="0.0258%" height="15" fill="rgb(211,33,43)" fg:x="4997" fg:w="10"/><text x="13.1179%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (9 samples, 0.02%)</title><rect x="12.8705%" y="373" width="0.0232%" height="15" fill="rgb(245,58,50)" fg:x="4998" fg:w="9"/><text x="13.1205%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (9 samples, 0.02%)</title><rect x="12.8705%" y="357" width="0.0232%" height="15" fill="rgb(244,68,36)" fg:x="4998" fg:w="9"/><text x="13.1205%" y="367.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (78 samples, 0.20%)</title><rect x="12.8679%" y="453" width="0.2009%" height="15" fill="rgb(232,229,15)" fg:x="4997" fg:w="78"/><text x="13.1179%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (68 samples, 0.18%)</title><rect x="12.8937%" y="437" width="0.1751%" height="15" fill="rgb(254,30,23)" fg:x="5007" fg:w="68"/><text x="13.1437%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (66 samples, 0.17%)</title><rect x="12.8988%" y="421" width="0.1700%" height="15" fill="rgb(235,160,14)" fg:x="5009" fg:w="66"/><text x="13.1488%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_swap (66 samples, 0.17%)</title><rect x="12.8988%" y="405" width="0.1700%" height="15" fill="rgb(212,155,44)" fg:x="5009" fg:w="66"/><text x="13.1488%" y="415.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="13.0688%" y="453" width="0.0129%" height="15" fill="rgb(226,2,50)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="463.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="13.0688%" y="437" width="0.0129%" height="15" fill="rgb(234,177,6)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="447.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="13.0688%" y="421" width="0.0129%" height="15" fill="rgb(217,24,9)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="431.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="13.0688%" y="405" width="0.0129%" height="15" fill="rgb(220,13,46)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="415.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="13.0688%" y="389" width="0.0129%" height="15" fill="rgb(239,221,27)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="399.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="13.0688%" y="373" width="0.0129%" height="15" fill="rgb(222,198,25)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="383.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="13.0688%" y="357" width="0.0129%" height="15" fill="rgb(211,99,13)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="367.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="13.0688%" y="341" width="0.0129%" height="15" fill="rgb(232,111,31)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="351.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="13.0688%" y="325" width="0.0129%" height="15" fill="rgb(245,82,37)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="335.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="13.0688%" y="309" width="0.0129%" height="15" fill="rgb(227,149,46)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="319.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="13.0688%" y="293" width="0.0129%" height="15" fill="rgb(218,36,50)" fg:x="5075" fg:w="5"/><text x="13.3188%" y="303.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (88 samples, 0.23%)</title><rect x="12.8679%" y="469" width="0.2266%" height="15" fill="rgb(226,80,48)" fg:x="4997" fg:w="88"/><text x="13.1179%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (5 samples, 0.01%)</title><rect x="13.0817%" y="453" width="0.0129%" height="15" fill="rgb(238,224,15)" fg:x="5080" fg:w="5"/><text x="13.3317%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;std::collections::hash::map::HashMap&lt;core::num::nonzero::NonZeroU32,alloc::sync::Weak&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt;&gt;&gt; (85 samples, 0.22%)</title><rect x="13.0945%" y="469" width="0.2189%" height="15" fill="rgb(241,136,10)" fg:x="5085" fg:w="85"/><text x="13.3445%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (85 samples, 0.22%)</title><rect x="13.0945%" y="453" width="0.2189%" height="15" fill="rgb(208,32,45)" fg:x="5085" fg:w="85"/><text x="13.3445%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (85 samples, 0.22%)</title><rect x="13.0945%" y="437" width="0.2189%" height="15" fill="rgb(207,135,9)" fg:x="5085" fg:w="85"/><text x="13.3445%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (76 samples, 0.20%)</title><rect x="13.1177%" y="421" width="0.1957%" height="15" fill="rgb(206,86,44)" fg:x="5094" fg:w="76"/><text x="13.3677%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (76 samples, 0.20%)</title><rect x="13.1177%" y="405" width="0.1957%" height="15" fill="rgb(245,177,15)" fg:x="5094" fg:w="76"/><text x="13.3677%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (66 samples, 0.17%)</title><rect x="13.3134%" y="469" width="0.1700%" height="15" fill="rgb(206,64,50)" fg:x="5170" fg:w="66"/><text x="13.5634%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (66 samples, 0.17%)</title><rect x="13.3134%" y="453" width="0.1700%" height="15" fill="rgb(234,36,40)" fg:x="5170" fg:w="66"/><text x="13.5634%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (66 samples, 0.17%)</title><rect x="13.3134%" y="437" width="0.1700%" height="15" fill="rgb(213,64,8)" fg:x="5170" fg:w="66"/><text x="13.5634%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (57 samples, 0.15%)</title><rect x="13.3366%" y="421" width="0.1468%" height="15" fill="rgb(210,75,36)" fg:x="5179" fg:w="57"/><text x="13.5866%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (57 samples, 0.15%)</title><rect x="13.3366%" y="405" width="0.1468%" height="15" fill="rgb(229,88,21)" fg:x="5179" fg:w="57"/><text x="13.5866%" y="415.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (4 samples, 0.01%)</title><rect x="13.5529%" y="325" width="0.0103%" height="15" fill="rgb(252,204,47)" fg:x="5263" fg:w="4"/><text x="13.8029%" y="335.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::c_rounds (20 samples, 0.05%)</title><rect x="13.5220%" y="341" width="0.0515%" height="15" fill="rgb(208,77,27)" fg:x="5251" fg:w="20"/><text x="13.7720%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (4 samples, 0.01%)</title><rect x="13.5632%" y="325" width="0.0103%" height="15" fill="rgb(221,76,26)" fg:x="5267" fg:w="4"/><text x="13.8132%" y="335.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (7 samples, 0.02%)</title><rect x="13.6018%" y="325" width="0.0180%" height="15" fill="rgb(225,139,18)" fg:x="5282" fg:w="7"/><text x="13.8518%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::finish (62 samples, 0.16%)</title><rect x="13.4963%" y="389" width="0.1597%" height="15" fill="rgb(230,137,11)" fg:x="5241" fg:w="62"/><text x="13.7463%" y="399.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::finish (62 samples, 0.16%)</title><rect x="13.4963%" y="373" width="0.1597%" height="15" fill="rgb(212,28,1)" fg:x="5241" fg:w="62"/><text x="13.7463%" y="383.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::finish (62 samples, 0.16%)</title><rect x="13.4963%" y="357" width="0.1597%" height="15" fill="rgb(248,164,17)" fg:x="5241" fg:w="62"/><text x="13.7463%" y="367.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::d_rounds (32 samples, 0.08%)</title><rect x="13.5735%" y="341" width="0.0824%" height="15" fill="rgb(222,171,42)" fg:x="5271" fg:w="32"/><text x="13.8235%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (14 samples, 0.04%)</title><rect x="13.6199%" y="325" width="0.0361%" height="15" fill="rgb(243,84,45)" fg:x="5289" fg:w="14"/><text x="13.8699%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::RandomState as core::hash::BuildHasher&gt;::build_hasher (17 samples, 0.04%)</title><rect x="13.6559%" y="389" width="0.0438%" height="15" fill="rgb(252,49,23)" fg:x="5303" fg:w="17"/><text x="13.9059%" y="399.50"></text></g><g><title>core::hash::sip::SipHasher13::new_with_keys (8 samples, 0.02%)</title><rect x="13.6791%" y="373" width="0.0206%" height="15" fill="rgb(215,19,7)" fg:x="5312" fg:w="8"/><text x="13.9291%" y="383.50"></text></g><g><title>core::hash::sip::Hasher&lt;S&gt;::new_with_keys (8 samples, 0.02%)</title><rect x="13.6791%" y="357" width="0.0206%" height="15" fill="rgb(238,81,41)" fg:x="5312" fg:w="8"/><text x="13.9291%" y="367.50"></text></g><g><title>core::hash::sip::Hasher&lt;S&gt;::reset (8 samples, 0.02%)</title><rect x="13.6791%" y="341" width="0.0206%" height="15" fill="rgb(210,199,37)" fg:x="5312" fg:w="8"/><text x="13.9291%" y="351.50"></text></g><g><title>hashbrown::map::make_hash (104 samples, 0.27%)</title><rect x="13.4911%" y="421" width="0.2678%" height="15" fill="rgb(244,192,49)" fg:x="5239" fg:w="104"/><text x="13.7411%" y="431.50"></text></g><g><title>core::hash::BuildHasher::hash_one (104 samples, 0.27%)</title><rect x="13.4911%" y="405" width="0.2678%" height="15" fill="rgb(226,211,11)" fg:x="5239" fg:w="104"/><text x="13.7411%" y="415.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (23 samples, 0.06%)</title><rect x="13.6997%" y="389" width="0.0592%" height="15" fill="rgb(236,162,54)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="399.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (23 samples, 0.06%)</title><rect x="13.6997%" y="373" width="0.0592%" height="15" fill="rgb(220,229,9)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="383.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for u32&gt;::hash (23 samples, 0.06%)</title><rect x="13.6997%" y="357" width="0.0592%" height="15" fill="rgb(250,87,22)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="367.50"></text></g><g><title>core::hash::Hasher::write_u32 (23 samples, 0.06%)</title><rect x="13.6997%" y="341" width="0.0592%" height="15" fill="rgb(239,43,17)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="351.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::write (23 samples, 0.06%)</title><rect x="13.6997%" y="325" width="0.0592%" height="15" fill="rgb(231,177,25)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="335.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::write (23 samples, 0.06%)</title><rect x="13.6997%" y="309" width="0.0592%" height="15" fill="rgb(219,179,1)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="319.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::write (23 samples, 0.06%)</title><rect x="13.6997%" y="293" width="0.0592%" height="15" fill="rgb(238,219,53)" fg:x="5320" fg:w="23"/><text x="13.9497%" y="303.50"></text></g><g><title>core::hash::sip::u8to64_le (15 samples, 0.04%)</title><rect x="13.7203%" y="277" width="0.0386%" height="15" fill="rgb(232,167,36)" fg:x="5328" fg:w="15"/><text x="13.9703%" y="287.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find::_{{closure}} (5 samples, 0.01%)</title><rect x="13.7847%" y="373" width="0.0129%" height="15" fill="rgb(244,19,51)" fg:x="5353" fg:w="5"/><text x="14.0347%" y="383.50"></text></g><g><title>hashbrown::raw::h2 (8 samples, 0.02%)</title><rect x="13.7975%" y="373" width="0.0206%" height="15" fill="rgb(224,6,22)" fg:x="5358" fg:w="8"/><text x="14.0475%" y="383.50"></text></g><g><title>hashbrown::raw::sse2::Group::load (29 samples, 0.07%)</title><rect x="13.8181%" y="373" width="0.0747%" height="15" fill="rgb(224,145,5)" fg:x="5366" fg:w="29"/><text x="14.0681%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_loadu_si128 (29 samples, 0.07%)</title><rect x="13.8181%" y="357" width="0.0747%" height="15" fill="rgb(234,130,49)" fg:x="5366" fg:w="29"/><text x="14.0681%" y="367.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (29 samples, 0.07%)</title><rect x="13.8181%" y="341" width="0.0747%" height="15" fill="rgb(254,6,2)" fg:x="5366" fg:w="29"/><text x="14.0681%" y="351.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (163 samples, 0.42%)</title><rect x="13.4911%" y="437" width="0.4197%" height="15" fill="rgb(208,96,46)" fg:x="5239" fg:w="163"/><text x="13.7411%" y="447.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::get (59 samples, 0.15%)</title><rect x="13.7589%" y="421" width="0.1519%" height="15" fill="rgb(239,3,39)" fg:x="5343" fg:w="59"/><text x="14.0089%" y="431.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find (59 samples, 0.15%)</title><rect x="13.7589%" y="405" width="0.1519%" height="15" fill="rgb(233,210,1)" fg:x="5343" fg:w="59"/><text x="14.0089%" y="415.50"></text></g><g><title>hashbrown::raw::RawTableInner&lt;A&gt;::find_inner (59 samples, 0.15%)</title><rect x="13.7589%" y="389" width="0.1519%" height="15" fill="rgb(244,137,37)" fg:x="5343" fg:w="59"/><text x="14.0089%" y="399.50"></text></g><g><title>hashbrown::raw::sse2::Group::match_byte (7 samples, 0.02%)</title><rect x="13.8928%" y="373" width="0.0180%" height="15" fill="rgb(240,136,2)" fg:x="5395" fg:w="7"/><text x="14.1428%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_movemask_epi8 (7 samples, 0.02%)</title><rect x="13.8928%" y="357" width="0.0180%" height="15" fill="rgb(239,18,37)" fg:x="5395" fg:w="7"/><text x="14.1428%" y="367.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (164 samples, 0.42%)</title><rect x="13.4911%" y="469" width="0.4223%" height="15" fill="rgb(218,185,22)" fg:x="5239" fg:w="164"/><text x="13.7411%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (164 samples, 0.42%)</title><rect x="13.4911%" y="453" width="0.4223%" height="15" fill="rgb(225,218,4)" fg:x="5239" fg:w="164"/><text x="13.7411%" y="463.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="13.9315%" y="437" width="0.0129%" height="15" fill="rgb(230,182,32)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="447.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="13.9315%" y="421" width="0.0129%" height="15" fill="rgb(242,56,43)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="431.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="13.9315%" y="405" width="0.0129%" height="15" fill="rgb(233,99,24)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="415.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="13.9315%" y="389" width="0.0129%" height="15" fill="rgb(234,209,42)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="399.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="13.9315%" y="373" width="0.0129%" height="15" fill="rgb(227,7,12)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="383.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="13.9315%" y="357" width="0.0129%" height="15" fill="rgb(245,203,43)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="367.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="13.9315%" y="341" width="0.0129%" height="15" fill="rgb(238,205,33)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="351.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="13.9315%" y="325" width="0.0129%" height="15" fill="rgb(231,56,7)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="335.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="13.9315%" y="309" width="0.0129%" height="15" fill="rgb(244,186,29)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="319.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="13.9315%" y="293" width="0.0129%" height="15" fill="rgb(234,111,31)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="303.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="13.9315%" y="277" width="0.0129%" height="15" fill="rgb(241,149,10)" fg:x="5410" fg:w="5"/><text x="14.1815%" y="287.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (42 samples, 0.11%)</title><rect x="13.9134%" y="469" width="0.1082%" height="15" fill="rgb(249,206,44)" fg:x="5403" fg:w="42"/><text x="14.1634%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (38 samples, 0.10%)</title><rect x="13.9237%" y="453" width="0.0979%" height="15" fill="rgb(251,153,30)" fg:x="5407" fg:w="38"/><text x="14.1737%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (30 samples, 0.08%)</title><rect x="13.9443%" y="437" width="0.0773%" height="15" fill="rgb(239,152,38)" fg:x="5415" fg:w="30"/><text x="14.1943%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (30 samples, 0.08%)</title><rect x="13.9443%" y="421" width="0.0773%" height="15" fill="rgb(249,139,47)" fg:x="5415" fg:w="30"/><text x="14.1943%" y="431.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="14.0654%" y="437" width="0.0129%" height="15" fill="rgb(244,64,35)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="447.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="14.0654%" y="421" width="0.0129%" height="15" fill="rgb(216,46,15)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="431.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="14.0654%" y="405" width="0.0129%" height="15" fill="rgb(250,74,19)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="415.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="14.0654%" y="389" width="0.0129%" height="15" fill="rgb(249,42,33)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="399.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="14.0654%" y="373" width="0.0129%" height="15" fill="rgb(242,149,17)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="383.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="14.0654%" y="357" width="0.0129%" height="15" fill="rgb(244,29,21)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="367.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="14.0654%" y="341" width="0.0129%" height="15" fill="rgb(220,130,37)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="351.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="14.0654%" y="325" width="0.0129%" height="15" fill="rgb(211,67,2)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="335.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="14.0654%" y="309" width="0.0129%" height="15" fill="rgb(235,68,52)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="319.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="14.0654%" y="293" width="0.0129%" height="15" fill="rgb(246,142,3)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="303.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="14.0654%" y="277" width="0.0129%" height="15" fill="rgb(241,25,7)" fg:x="5462" fg:w="5"/><text x="14.3154%" y="287.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (128 samples, 0.33%)</title><rect x="14.0782%" y="437" width="0.3296%" height="15" fill="rgb(242,119,39)" fg:x="5467" fg:w="128"/><text x="14.3282%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (128 samples, 0.33%)</title><rect x="14.0782%" y="421" width="0.3296%" height="15" fill="rgb(241,98,45)" fg:x="5467" fg:w="128"/><text x="14.3282%" y="431.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (162 samples, 0.42%)</title><rect x="14.0216%" y="469" width="0.4172%" height="15" fill="rgb(254,28,30)" fg:x="5445" fg:w="162"/><text x="14.2716%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (162 samples, 0.42%)</title><rect x="14.0216%" y="453" width="0.4172%" height="15" fill="rgb(241,142,54)" fg:x="5445" fg:w="162"/><text x="14.2716%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::is_read_lockable (12 samples, 0.03%)</title><rect x="14.4078%" y="437" width="0.0309%" height="15" fill="rgb(222,85,15)" fg:x="5595" fg:w="12"/><text x="14.6578%" y="447.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (5 samples, 0.01%)</title><rect x="14.4413%" y="453" width="0.0129%" height="15" fill="rgb(210,85,47)" fg:x="5608" fg:w="5"/><text x="14.6913%" y="463.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::check (13 samples, 0.03%)</title><rect x="14.4388%" y="469" width="0.0335%" height="15" fill="rgb(224,206,25)" fg:x="5607" fg:w="13"/><text x="14.6888%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicU64::load (7 samples, 0.02%)</title><rect x="14.4542%" y="453" width="0.0180%" height="15" fill="rgb(243,201,19)" fg:x="5613" fg:w="7"/><text x="14.7042%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_load (7 samples, 0.02%)</title><rect x="14.4542%" y="437" width="0.0180%" height="15" fill="rgb(236,59,4)" fg:x="5613" fg:w="7"/><text x="14.7042%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::push (20 samples, 0.05%)</title><rect x="14.5933%" y="453" width="0.0515%" height="15" fill="rgb(254,179,45)" fg:x="5667" fg:w="20"/><text x="14.8433%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push (20 samples, 0.05%)</title><rect x="14.5933%" y="437" width="0.0515%" height="15" fill="rgb(226,14,10)" fg:x="5667" fg:w="20"/><text x="14.8433%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::try_push (20 samples, 0.05%)</title><rect x="14.5933%" y="421" width="0.0515%" height="15" fill="rgb(244,27,41)" fg:x="5667" fg:w="20"/><text x="14.8433%" y="431.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push_unchecked (13 samples, 0.03%)</title><rect x="14.6113%" y="405" width="0.0335%" height="15" fill="rgb(235,35,32)" fg:x="5674" fg:w="13"/><text x="14.8613%" y="415.50"></text></g><g><title>core::ptr::write (12 samples, 0.03%)</title><rect x="14.6139%" y="389" width="0.0309%" height="15" fill="rgb(218,68,31)" fg:x="5675" fg:w="12"/><text x="14.8639%" y="399.50"></text></g><g><title>core::array::equality::_&lt;impl core::cmp::PartialEq&lt;[B: N]&gt; for [A: N]&gt;::ne (5 samples, 0.01%)</title><rect x="14.6448%" y="453" width="0.0129%" height="15" fill="rgb(207,120,37)" fg:x="5687" fg:w="5"/><text x="14.8948%" y="463.50"></text></g><g><title>&lt;T as core::array::equality::SpecArrayEq&lt;U,_&gt;&gt;::spec_ne (5 samples, 0.01%)</title><rect x="14.6448%" y="437" width="0.0129%" height="15" fill="rgb(227,98,0)" fg:x="5687" fg:w="5"/><text x="14.8948%" y="447.50"></text></g><g><title>&lt;T as core::array::equality::SpecArrayEq&lt;U,_&gt;&gt;::spec_eq (5 samples, 0.01%)</title><rect x="14.6448%" y="421" width="0.0129%" height="15" fill="rgb(207,7,3)" fg:x="5687" fg:w="5"/><text x="14.8948%" y="431.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init_read (7 samples, 0.02%)</title><rect x="14.6628%" y="453" width="0.0180%" height="15" fill="rgb(206,98,19)" fg:x="5694" fg:w="7"/><text x="14.9128%" y="463.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::read (7 samples, 0.02%)</title><rect x="14.6628%" y="437" width="0.0180%" height="15" fill="rgb(217,5,26)" fg:x="5694" fg:w="7"/><text x="14.9128%" y="447.50"></text></g><g><title>core::ptr::read (7 samples, 0.02%)</title><rect x="14.6628%" y="421" width="0.0180%" height="15" fill="rgb(235,190,38)" fg:x="5694" fg:w="7"/><text x="14.9128%" y="431.50"></text></g><g><title>core::mem::maybe_uninit::MaybeUninit&lt;T&gt;::assume_init (7 samples, 0.02%)</title><rect x="14.6628%" y="405" width="0.0180%" height="15" fill="rgb(247,86,24)" fg:x="5694" fg:w="7"/><text x="14.9128%" y="415.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_shl (6 samples, 0.02%)</title><rect x="14.6885%" y="453" width="0.0155%" height="15" fill="rgb(205,101,16)" fg:x="5704" fg:w="6"/><text x="14.9385%" y="463.50"></text></g><g><title>core::num::&lt;impl u64&gt;::unchecked_shl (6 samples, 0.02%)</title><rect x="14.6885%" y="437" width="0.0155%" height="15" fill="rgb(246,168,33)" fg:x="5704" fg:w="6"/><text x="14.9385%" y="447.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (98 samples, 0.25%)</title><rect x="14.4722%" y="469" width="0.2524%" height="15" fill="rgb(231,114,1)" fg:x="5620" fg:w="98"/><text x="14.7222%" y="479.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::drop_in_place (5 samples, 0.01%)</title><rect x="14.7117%" y="453" width="0.0129%" height="15" fill="rgb(207,184,53)" fg:x="5713" fg:w="5"/><text x="14.9617%" y="463.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (26 samples, 0.07%)</title><rect x="14.7246%" y="453" width="0.0670%" height="15" fill="rgb(224,95,51)" fg:x="5718" fg:w="26"/><text x="14.9746%" y="463.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (26 samples, 0.07%)</title><rect x="14.7246%" y="437" width="0.0670%" height="15" fill="rgb(212,188,45)" fg:x="5718" fg:w="26"/><text x="14.9746%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (26 samples, 0.07%)</title><rect x="14.7246%" y="421" width="0.0670%" height="15" fill="rgb(223,154,38)" fg:x="5718" fg:w="26"/><text x="14.9746%" y="431.50"></text></g><g><title>zssp::zeta::from_nonce (32 samples, 0.08%)</title><rect x="14.7246%" y="469" width="0.0824%" height="15" fill="rgb(251,22,52)" fg:x="5718" fg:w="32"/><text x="14.9746%" y="479.50"></text></g><g><title>core::num::&lt;impl u64&gt;::from_be_bytes (6 samples, 0.02%)</title><rect x="14.7915%" y="453" width="0.0155%" height="15" fill="rgb(229,209,22)" fg:x="5744" fg:w="6"/><text x="15.0415%" y="463.50"></text></g><g><title>core::num::&lt;impl u64&gt;::from_be (6 samples, 0.02%)</title><rect x="14.7915%" y="437" width="0.0155%" height="15" fill="rgb(234,138,34)" fg:x="5744" fg:w="6"/><text x="15.0415%" y="447.50"></text></g><g><title>core::num::&lt;impl u64&gt;::swap_bytes (6 samples, 0.02%)</title><rect x="14.7915%" y="421" width="0.0155%" height="15" fill="rgb(212,95,11)" fg:x="5744" fg:w="6"/><text x="15.0415%" y="431.50"></text></g><g><title>&lt;alloc::vec::Vec&lt;T,A&gt; as core::convert::AsMut&lt;[T]&gt;&gt;::as_mut (4 samples, 0.01%)</title><rect x="14.8405%" y="453" width="0.0103%" height="15" fill="rgb(240,179,47)" fg:x="5763" fg:w="4"/><text x="15.0905%" y="463.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (69 samples, 0.18%)</title><rect x="14.8585%" y="453" width="0.1777%" height="15" fill="rgb(240,163,11)" fg:x="5770" fg:w="69"/><text x="15.1085%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (69 samples, 0.18%)</title><rect x="14.8585%" y="437" width="0.1777%" height="15" fill="rgb(236,37,12)" fg:x="5770" fg:w="69"/><text x="15.1085%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (68 samples, 0.18%)</title><rect x="14.8611%" y="421" width="0.1751%" height="15" fill="rgb(232,164,16)" fg:x="5771" fg:w="68"/><text x="15.1111%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (68 samples, 0.18%)</title><rect x="14.8611%" y="405" width="0.1751%" height="15" fill="rgb(244,205,15)" fg:x="5771" fg:w="68"/><text x="15.1111%" y="415.50"></text></g><g><title>CRYPTO_gcm128_decrypt (249 samples, 0.64%)</title><rect x="15.4508%" y="357" width="0.6412%" height="15" fill="rgb(223,117,47)" fg:x="6000" fg:w="249"/><text x="15.7008%" y="367.50"></text></g><g><title>[libcrypto.so.3] (120 samples, 0.31%)</title><rect x="15.7830%" y="341" width="0.3090%" height="15" fill="rgb(244,107,35)" fg:x="6129" fg:w="120"/><text x="16.0330%" y="351.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="16.0791%" y="325" width="0.0129%" height="15" fill="rgb(205,140,8)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="16.0791%" y="309" width="0.0129%" height="15" fill="rgb(228,84,46)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="16.0791%" y="293" width="0.0129%" height="15" fill="rgb(254,188,9)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="16.0791%" y="277" width="0.0129%" height="15" fill="rgb(206,112,54)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="16.0791%" y="261" width="0.0129%" height="15" fill="rgb(216,84,49)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="16.0791%" y="245" width="0.0129%" height="15" fill="rgb(214,194,35)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="16.0791%" y="229" width="0.0129%" height="15" fill="rgb(249,28,3)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="16.0791%" y="213" width="0.0129%" height="15" fill="rgb(222,56,52)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="16.0791%" y="197" width="0.0129%" height="15" fill="rgb(245,217,50)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="16.0791%" y="181" width="0.0129%" height="15" fill="rgb(213,201,24)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="191.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="16.0791%" y="165" width="0.0129%" height="15" fill="rgb(248,116,28)" fg:x="6244" fg:w="5"/><text x="16.3291%" y="175.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (478 samples, 1.23%)</title><rect x="16.0920%" y="357" width="1.2309%" height="15" fill="rgb(219,72,43)" fg:x="6249" fg:w="478"/><text x="16.3420%" y="367.50"></text></g><g><title>[libcrypto.so.3] (360 samples, 0.93%)</title><rect x="16.3958%" y="341" width="0.9270%" height="15" fill="rgb(209,138,14)" fg:x="6367" fg:w="360"/><text x="16.6458%" y="351.50"></text></g><g><title>[libcrypto.so.3] (22 samples, 0.06%)</title><rect x="17.2662%" y="325" width="0.0567%" height="15" fill="rgb(222,18,33)" fg:x="6705" fg:w="22"/><text x="17.5162%" y="335.50"></text></g><g><title>CRYPTO_gcm128_setiv (23 samples, 0.06%)</title><rect x="17.3229%" y="357" width="0.0592%" height="15" fill="rgb(213,199,7)" fg:x="6727" fg:w="23"/><text x="17.5729%" y="367.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="17.3306%" y="341" width="0.0515%" height="15" fill="rgb(250,110,10)" fg:x="6730" fg:w="20"/><text x="17.5806%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (4,848 samples, 12.48%)</title><rect x="15.0362%" y="453" width="12.4842%" height="15" fill="rgb(248,123,6)" fg:x="5839" fg:w="4848"/><text x="15.2862%" y="463.50">&lt;zssp::crypto_impl:..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4,846 samples, 12.48%)</title><rect x="15.0413%" y="437" width="12.4791%" height="15" fill="rgb(206,91,31)" fg:x="5841" fg:w="4846"/><text x="15.2913%" y="447.50">zssp::crypto_impl::..</text></g><g><title>EVP_DecryptUpdate (4,846 samples, 12.48%)</title><rect x="15.0413%" y="421" width="12.4791%" height="15" fill="rgb(211,154,13)" fg:x="5841" fg:w="4846"/><text x="15.2913%" y="431.50">EVP_DecryptUpdate</text></g><g><title>[libcrypto.so.3] (4,745 samples, 12.22%)</title><rect x="15.3014%" y="405" width="12.2190%" height="15" fill="rgb(225,148,7)" fg:x="5942" fg:w="4745"/><text x="15.5514%" y="415.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,741 samples, 12.21%)</title><rect x="15.3117%" y="389" width="12.2087%" height="15" fill="rgb(220,160,43)" fg:x="5946" fg:w="4741"/><text x="15.5617%" y="399.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,719 samples, 12.15%)</title><rect x="15.3684%" y="373" width="12.1520%" height="15" fill="rgb(213,52,39)" fg:x="5968" fg:w="4719"/><text x="15.6184%" y="383.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,937 samples, 10.14%)</title><rect x="17.3821%" y="357" width="10.1383%" height="15" fill="rgb(243,137,7)" fg:x="6750" fg:w="3937"/><text x="17.6321%" y="367.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,769 samples, 9.71%)</title><rect x="17.8147%" y="341" width="9.7057%" height="15" fill="rgb(230,79,13)" fg:x="6918" fg:w="3769"/><text x="18.0647%" y="351.50">[libcrypto.so...</text></g><g><title>asm_sysvec_apic_timer_interrupt (6 samples, 0.02%)</title><rect x="27.5050%" y="325" width="0.0155%" height="15" fill="rgb(247,105,23)" fg:x="10681" fg:w="6"/><text x="27.7550%" y="335.50"></text></g><g><title>sysvec_apic_timer_interrupt (6 samples, 0.02%)</title><rect x="27.5050%" y="309" width="0.0155%" height="15" fill="rgb(223,179,41)" fg:x="10681" fg:w="6"/><text x="27.7550%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="27.5075%" y="293" width="0.0129%" height="15" fill="rgb(218,9,34)" fg:x="10682" fg:w="5"/><text x="27.7575%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="27.5075%" y="277" width="0.0129%" height="15" fill="rgb(222,106,8)" fg:x="10682" fg:w="5"/><text x="27.7575%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="27.5075%" y="261" width="0.0129%" height="15" fill="rgb(211,220,0)" fg:x="10682" fg:w="5"/><text x="27.7575%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="27.5075%" y="245" width="0.0129%" height="15" fill="rgb(229,52,16)" fg:x="10682" fg:w="5"/><text x="27.7575%" y="255.50"></text></g><g><title>schedule (4 samples, 0.01%)</title><rect x="27.5101%" y="229" width="0.0103%" height="15" fill="rgb(212,155,18)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="239.50"></text></g><g><title>__schedule (4 samples, 0.01%)</title><rect x="27.5101%" y="213" width="0.0103%" height="15" fill="rgb(242,21,14)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="27.5101%" y="197" width="0.0103%" height="15" fill="rgb(222,19,48)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="27.5101%" y="181" width="0.0103%" height="15" fill="rgb(232,45,27)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="191.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="27.5101%" y="165" width="0.0103%" height="15" fill="rgb(249,103,42)" fg:x="10683" fg:w="4"/><text x="27.7601%" y="175.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec&gt; (13 samples, 0.03%)</title><rect x="27.5281%" y="437" width="0.0335%" height="15" fill="rgb(246,81,33)" fg:x="10690" fg:w="13"/><text x="27.7781%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (13 samples, 0.03%)</title><rect x="27.5281%" y="421" width="0.0335%" height="15" fill="rgb(252,33,42)" fg:x="10690" fg:w="13"/><text x="27.7781%" y="431.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (13 samples, 0.03%)</title><rect x="27.5281%" y="405" width="0.0335%" height="15" fill="rgb(209,212,41)" fg:x="10690" fg:w="13"/><text x="27.7781%" y="415.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (12 samples, 0.03%)</title><rect x="27.5307%" y="389" width="0.0309%" height="15" fill="rgb(207,154,6)" fg:x="10691" fg:w="12"/><text x="27.7807%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (12 samples, 0.03%)</title><rect x="27.5307%" y="373" width="0.0309%" height="15" fill="rgb(223,64,47)" fg:x="10691" fg:w="12"/><text x="27.7807%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_swap (12 samples, 0.03%)</title><rect x="27.5307%" y="357" width="0.0309%" height="15" fill="rgb(211,161,38)" fg:x="10691" fg:w="12"/><text x="27.7807%" y="367.50"></text></g><g><title>[libc.so.6] (6 samples, 0.02%)</title><rect x="27.6363%" y="341" width="0.0155%" height="15" fill="rgb(219,138,40)" fg:x="10732" fg:w="6"/><text x="27.8863%" y="351.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="27.6517%" y="341" width="0.0515%" height="15" fill="rgb(241,228,46)" fg:x="10738" fg:w="20"/><text x="27.9017%" y="351.50"></text></g><g><title>CRYPTO_gcm128_finish (40 samples, 0.10%)</title><rect x="27.6028%" y="357" width="0.1030%" height="15" fill="rgb(223,209,38)" fg:x="10719" fg:w="40"/><text x="27.8528%" y="367.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (59 samples, 0.15%)</title><rect x="27.5616%" y="437" width="0.1519%" height="15" fill="rgb(236,164,45)" fg:x="10703" fg:w="59"/><text x="27.8116%" y="447.50"></text></g><g><title>EVP_DecryptFinal_ex (59 samples, 0.15%)</title><rect x="27.5616%" y="421" width="0.1519%" height="15" fill="rgb(231,15,5)" fg:x="10703" fg:w="59"/><text x="27.8116%" y="431.50"></text></g><g><title>[libcrypto.so.3] (50 samples, 0.13%)</title><rect x="27.5848%" y="405" width="0.1288%" height="15" fill="rgb(252,35,15)" fg:x="10712" fg:w="50"/><text x="27.8348%" y="415.50"></text></g><g><title>[libcrypto.so.3] (50 samples, 0.13%)</title><rect x="27.5848%" y="389" width="0.1288%" height="15" fill="rgb(248,181,18)" fg:x="10712" fg:w="50"/><text x="27.8348%" y="399.50"></text></g><g><title>[libcrypto.so.3] (46 samples, 0.12%)</title><rect x="27.5951%" y="373" width="0.1185%" height="15" fill="rgb(233,39,42)" fg:x="10716" fg:w="46"/><text x="27.8451%" y="383.50"></text></g><g><title>OSSL_PARAM_get_octet_string (5 samples, 0.01%)</title><rect x="27.8088%" y="389" width="0.0129%" height="15" fill="rgb(238,110,33)" fg:x="10799" fg:w="5"/><text x="28.0588%" y="399.50"></text></g><g><title>[libcrypto.so.3] (4 samples, 0.01%)</title><rect x="27.8114%" y="373" width="0.0103%" height="15" fill="rgb(233,195,10)" fg:x="10800" fg:w="4"/><text x="28.0614%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (27 samples, 0.07%)</title><rect x="27.8217%" y="389" width="0.0695%" height="15" fill="rgb(254,105,3)" fg:x="10804" fg:w="27"/><text x="28.0717%" y="399.50"></text></g><g><title>[libc.so.6] (16 samples, 0.04%)</title><rect x="27.8500%" y="373" width="0.0412%" height="15" fill="rgb(221,225,9)" fg:x="10815" fg:w="16"/><text x="28.1000%" y="383.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (145 samples, 0.37%)</title><rect x="27.5204%" y="453" width="0.3734%" height="15" fill="rgb(224,227,45)" fg:x="10687" fg:w="145"/><text x="27.7704%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::set_tag (70 samples, 0.18%)</title><rect x="27.7135%" y="437" width="0.1803%" height="15" fill="rgb(229,198,43)" fg:x="10762" fg:w="70"/><text x="27.9635%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (70 samples, 0.18%)</title><rect x="27.7135%" y="421" width="0.1803%" height="15" fill="rgb(206,209,35)" fg:x="10762" fg:w="70"/><text x="27.9635%" y="431.50"></text></g><g><title>[libcrypto.so.3] (40 samples, 0.10%)</title><rect x="27.7908%" y="405" width="0.1030%" height="15" fill="rgb(245,195,53)" fg:x="10792" fg:w="40"/><text x="28.0408%" y="415.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (18 samples, 0.05%)</title><rect x="27.8964%" y="437" width="0.0464%" height="15" fill="rgb(240,92,26)" fg:x="10833" fg:w="18"/><text x="28.1464%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (18 samples, 0.05%)</title><rect x="27.8964%" y="421" width="0.0464%" height="15" fill="rgb(207,40,23)" fg:x="10833" fg:w="18"/><text x="28.1464%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (17 samples, 0.04%)</title><rect x="27.8990%" y="405" width="0.0438%" height="15" fill="rgb(223,111,35)" fg:x="10834" fg:w="17"/><text x="28.1490%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (17 samples, 0.04%)</title><rect x="27.8990%" y="389" width="0.0438%" height="15" fill="rgb(229,147,28)" fg:x="10834" fg:w="17"/><text x="28.1490%" y="399.50"></text></g><g><title>[libc.so.6] (14 samples, 0.04%)</title><rect x="28.1951%" y="341" width="0.0361%" height="15" fill="rgb(211,29,28)" fg:x="10949" fg:w="14"/><text x="28.4451%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (37 samples, 0.10%)</title><rect x="28.1487%" y="357" width="0.0953%" height="15" fill="rgb(228,72,33)" fg:x="10931" fg:w="37"/><text x="28.3987%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="28.2311%" y="341" width="0.0129%" height="15" fill="rgb(205,214,31)" fg:x="10963" fg:w="5"/><text x="28.4811%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (70 samples, 0.18%)</title><rect x="28.0715%" y="389" width="0.1803%" height="15" fill="rgb(224,111,15)" fg:x="10901" fg:w="70"/><text x="28.3215%" y="399.50"></text></g><g><title>[libcrypto.so.3] (47 samples, 0.12%)</title><rect x="28.1307%" y="373" width="0.1210%" height="15" fill="rgb(253,21,26)" fg:x="10924" fg:w="47"/><text x="28.3807%" y="383.50"></text></g><g><title>[libc.so.6] (22 samples, 0.06%)</title><rect x="28.4063%" y="341" width="0.0567%" height="15" fill="rgb(245,139,43)" fg:x="11031" fg:w="22"/><text x="28.6563%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (50 samples, 0.13%)</title><rect x="28.3470%" y="357" width="0.1288%" height="15" fill="rgb(252,170,7)" fg:x="11008" fg:w="50"/><text x="28.5970%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="28.4629%" y="341" width="0.0129%" height="15" fill="rgb(231,118,14)" fg:x="11053" fg:w="5"/><text x="28.7129%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (92 samples, 0.24%)</title><rect x="28.2517%" y="389" width="0.2369%" height="15" fill="rgb(238,83,0)" fg:x="10971" fg:w="92"/><text x="28.5017%" y="399.50"></text></g><g><title>[libcrypto.so.3] (72 samples, 0.19%)</title><rect x="28.3032%" y="373" width="0.1854%" height="15" fill="rgb(221,39,39)" fg:x="10991" fg:w="72"/><text x="28.5532%" y="383.50"></text></g><g><title>OSSL_PARAM_locate_const (5 samples, 0.01%)</title><rect x="28.4758%" y="357" width="0.0129%" height="15" fill="rgb(222,119,46)" fg:x="11058" fg:w="5"/><text x="28.7258%" y="367.50"></text></g><g><title>EVP_CIPHER_free (13 samples, 0.03%)</title><rect x="28.4887%" y="389" width="0.0335%" height="15" fill="rgb(222,165,49)" fg:x="11063" fg:w="13"/><text x="28.7387%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (46 samples, 0.12%)</title><rect x="28.5221%" y="389" width="0.1185%" height="15" fill="rgb(219,113,52)" fg:x="11076" fg:w="46"/><text x="28.7721%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (292 samples, 0.75%)</title><rect x="27.8938%" y="453" width="0.7519%" height="15" fill="rgb(214,7,15)" fg:x="10832" fg:w="292"/><text x="28.1438%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (273 samples, 0.70%)</title><rect x="27.9427%" y="437" width="0.7030%" height="15" fill="rgb(235,32,4)" fg:x="10851" fg:w="273"/><text x="28.1927%" y="447.50"></text></g><g><title>EVP_CipherInit_ex (272 samples, 0.70%)</title><rect x="27.9453%" y="421" width="0.7004%" height="15" fill="rgb(238,90,54)" fg:x="10852" fg:w="272"/><text x="28.1953%" y="431.50"></text></g><g><title>[libcrypto.so.3] (272 samples, 0.70%)</title><rect x="27.9453%" y="405" width="0.7004%" height="15" fill="rgb(213,208,19)" fg:x="10852" fg:w="272"/><text x="28.1953%" y="415.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (6 samples, 0.02%)</title><rect x="28.6560%" y="437" width="0.0155%" height="15" fill="rgb(233,156,4)" fg:x="11128" fg:w="6"/><text x="28.9060%" y="447.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (4 samples, 0.01%)</title><rect x="28.6612%" y="421" width="0.0103%" height="15" fill="rgb(207,194,5)" fg:x="11130" fg:w="4"/><text x="28.9112%" y="431.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (4 samples, 0.01%)</title><rect x="28.6612%" y="405" width="0.0103%" height="15" fill="rgb(206,111,30)" fg:x="11130" fg:w="4"/><text x="28.9112%" y="415.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (7 samples, 0.02%)</title><rect x="28.6560%" y="453" width="0.0180%" height="15" fill="rgb(243,70,54)" fg:x="11128" fg:w="7"/><text x="28.9060%" y="463.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::get_unchecked_ptr (6 samples, 0.02%)</title><rect x="28.6818%" y="405" width="0.0155%" height="15" fill="rgb(242,28,8)" fg:x="11138" fg:w="6"/><text x="28.9318%" y="415.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::add (6 samples, 0.02%)</title><rect x="28.6818%" y="389" width="0.0155%" height="15" fill="rgb(219,106,18)" fg:x="11138" fg:w="6"/><text x="28.9318%" y="399.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::offset (6 samples, 0.02%)</title><rect x="28.6818%" y="373" width="0.0155%" height="15" fill="rgb(244,222,10)" fg:x="11138" fg:w="6"/><text x="28.9318%" y="383.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (253 samples, 0.65%)</title><rect x="28.6741%" y="453" width="0.6515%" height="15" fill="rgb(236,179,52)" fg:x="11135" fg:w="253"/><text x="28.9241%" y="463.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (253 samples, 0.65%)</title><rect x="28.6741%" y="437" width="0.6515%" height="15" fill="rgb(213,23,39)" fg:x="11135" fg:w="253"/><text x="28.9241%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (250 samples, 0.64%)</title><rect x="28.6818%" y="421" width="0.6438%" height="15" fill="rgb(238,48,10)" fg:x="11138" fg:w="250"/><text x="28.9318%" y="431.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (244 samples, 0.63%)</title><rect x="28.6972%" y="405" width="0.6283%" height="15" fill="rgb(251,196,23)" fg:x="11144" fg:w="244"/><text x="28.9472%" y="415.50"></text></g><g><title>[libc.so.6] (242 samples, 0.62%)</title><rect x="28.7024%" y="389" width="0.6232%" height="15" fill="rgb(250,152,24)" fg:x="11146" fg:w="242"/><text x="28.9524%" y="399.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::update (15 samples, 0.04%)</title><rect x="29.3256%" y="453" width="0.0386%" height="15" fill="rgb(209,150,17)" fg:x="11388" fg:w="15"/><text x="29.5756%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_max (15 samples, 0.04%)</title><rect x="29.3256%" y="437" width="0.0386%" height="15" fill="rgb(234,202,34)" fg:x="11388" fg:w="15"/><text x="29.5756%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_umax (15 samples, 0.04%)</title><rect x="29.3256%" y="421" width="0.0386%" height="15" fill="rgb(253,148,53)" fg:x="11388" fg:w="15"/><text x="29.5756%" y="431.50"></text></g><g><title>zssp::zeta::receive_payload_in_place (5,655 samples, 14.56%)</title><rect x="14.8070%" y="469" width="14.5624%" height="15" fill="rgb(218,129,16)" fg:x="5750" fg:w="5655"/><text x="15.0570%" y="479.50">zssp::zeta::receive_pa..</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8,525 samples, 21.95%)</title><rect x="7.6069%" y="485" width="21.9530%" height="15" fill="rgb(216,85,19)" fg:x="2954" fg:w="8525"/><text x="7.8569%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::receive</text></g><g><title>zssp::zssp::parse_fragment_header (74 samples, 0.19%)</title><rect x="29.3694%" y="469" width="0.1906%" height="15" fill="rgb(235,228,7)" fg:x="11405" fg:w="74"/><text x="29.6194%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (60 samples, 0.15%)</title><rect x="29.6166%" y="437" width="0.1545%" height="15" fill="rgb(245,175,0)" fg:x="11501" fg:w="60"/><text x="29.8666%" y="447.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (60 samples, 0.15%)</title><rect x="29.6166%" y="421" width="0.1545%" height="15" fill="rgb(208,168,36)" fg:x="11501" fg:w="60"/><text x="29.8666%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (59 samples, 0.15%)</title><rect x="29.6191%" y="405" width="0.1519%" height="15" fill="rgb(246,171,24)" fg:x="11502" fg:w="59"/><text x="29.8691%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (54 samples, 0.14%)</title><rect x="29.6320%" y="389" width="0.1391%" height="15" fill="rgb(215,142,24)" fg:x="11507" fg:w="54"/><text x="29.8820%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_swap (54 samples, 0.14%)</title><rect x="29.6320%" y="373" width="0.1391%" height="15" fill="rgb(250,187,7)" fg:x="11507" fg:w="54"/><text x="29.8820%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (79 samples, 0.20%)</title><rect x="29.7711%" y="437" width="0.2034%" height="15" fill="rgb(228,66,33)" fg:x="11561" fg:w="79"/><text x="30.0211%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (77 samples, 0.20%)</title><rect x="29.7762%" y="421" width="0.1983%" height="15" fill="rgb(234,215,21)" fg:x="11563" fg:w="77"/><text x="30.0262%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (74 samples, 0.19%)</title><rect x="29.7839%" y="405" width="0.1906%" height="15" fill="rgb(222,191,20)" fg:x="11566" fg:w="74"/><text x="30.0339%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (74 samples, 0.19%)</title><rect x="29.7839%" y="389" width="0.1906%" height="15" fill="rgb(245,79,54)" fg:x="11566" fg:w="74"/><text x="30.0339%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (325 samples, 0.84%)</title><rect x="29.6011%" y="453" width="0.8369%" height="15" fill="rgb(240,10,37)" fg:x="11495" fg:w="325"/><text x="29.8511%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (180 samples, 0.46%)</title><rect x="29.9745%" y="437" width="0.4635%" height="15" fill="rgb(214,192,32)" fg:x="11640" fg:w="180"/><text x="30.2245%" y="447.50"></text></g><g><title>EVP_EncryptUpdate (180 samples, 0.46%)</title><rect x="29.9745%" y="421" width="0.4635%" height="15" fill="rgb(209,36,54)" fg:x="11640" fg:w="180"/><text x="30.2245%" y="431.50"></text></g><g><title>[libcrypto.so.3] (154 samples, 0.40%)</title><rect x="30.0415%" y="405" width="0.3966%" height="15" fill="rgb(220,10,11)" fg:x="11666" fg:w="154"/><text x="30.2915%" y="415.50"></text></g><g><title>[libcrypto.so.3] (123 samples, 0.32%)</title><rect x="30.1213%" y="389" width="0.3167%" height="15" fill="rgb(221,106,17)" fg:x="11697" fg:w="123"/><text x="30.3713%" y="399.50"></text></g><g><title>[libcrypto.so.3] (115 samples, 0.30%)</title><rect x="30.1419%" y="373" width="0.2961%" height="15" fill="rgb(251,142,44)" fg:x="11705" fg:w="115"/><text x="30.3919%" y="383.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::deref::Deref&gt;::deref (5 samples, 0.01%)</title><rect x="30.4380%" y="437" width="0.0129%" height="15" fill="rgb(238,13,15)" fg:x="11820" fg:w="5"/><text x="30.6880%" y="447.50"></text></g><g><title>CRYPTO_gcm128_encrypt (264 samples, 0.68%)</title><rect x="30.7419%" y="357" width="0.6798%" height="15" fill="rgb(208,107,27)" fg:x="11938" fg:w="264"/><text x="30.9919%" y="367.50"></text></g><g><title>[libcrypto.so.3] (144 samples, 0.37%)</title><rect x="31.0509%" y="341" width="0.3708%" height="15" fill="rgb(205,136,37)" fg:x="12058" fg:w="144"/><text x="31.3009%" y="351.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="32.6475%" y="325" width="0.0515%" height="15" fill="rgb(250,205,27)" fg:x="12678" fg:w="20"/><text x="32.8975%" y="335.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (501 samples, 1.29%)</title><rect x="31.4217%" y="357" width="1.2901%" height="15" fill="rgb(210,80,43)" fg:x="12202" fg:w="501"/><text x="31.6717%" y="367.50"></text></g><g><title>[libcrypto.so.3] (349 samples, 0.90%)</title><rect x="31.8131%" y="341" width="0.8987%" height="15" fill="rgb(247,160,36)" fg:x="12354" fg:w="349"/><text x="32.0631%" y="351.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="32.6990%" y="325" width="0.0129%" height="15" fill="rgb(234,13,49)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="32.6990%" y="309" width="0.0129%" height="15" fill="rgb(234,122,0)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="32.6990%" y="293" width="0.0129%" height="15" fill="rgb(207,146,38)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="32.6990%" y="277" width="0.0129%" height="15" fill="rgb(207,177,25)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="32.6990%" y="261" width="0.0129%" height="15" fill="rgb(211,178,42)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="32.6990%" y="245" width="0.0129%" height="15" fill="rgb(230,69,54)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="32.6990%" y="229" width="0.0129%" height="15" fill="rgb(214,135,41)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="32.6990%" y="213" width="0.0129%" height="15" fill="rgb(237,67,25)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="32.6990%" y="197" width="0.0129%" height="15" fill="rgb(222,189,50)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="32.6990%" y="181" width="0.0129%" height="15" fill="rgb(245,148,34)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="191.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="32.6990%" y="165" width="0.0129%" height="15" fill="rgb(222,29,6)" fg:x="12698" fg:w="5"/><text x="32.9490%" y="175.50"></text></g><g><title>CRYPTO_gcm128_setiv (23 samples, 0.06%)</title><rect x="32.7119%" y="357" width="0.0592%" height="15" fill="rgb(221,189,43)" fg:x="12703" fg:w="23"/><text x="32.9619%" y="367.50"></text></g><g><title>[libcrypto.so.3] (20 samples, 0.05%)</title><rect x="32.7196%" y="341" width="0.0515%" height="15" fill="rgb(207,36,27)" fg:x="12706" fg:w="20"/><text x="32.9696%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (3,870 samples, 9.97%)</title><rect x="30.4380%" y="453" width="9.9658%" height="15" fill="rgb(217,90,24)" fg:x="11820" fg:w="3870"/><text x="30.6880%" y="463.50">&lt;zssp::crypto_..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (3,865 samples, 9.95%)</title><rect x="30.4509%" y="437" width="9.9529%" height="15" fill="rgb(224,66,35)" fg:x="11825" fg:w="3865"/><text x="30.7009%" y="447.50">zssp::crypto_i..</text></g><g><title>EVP_EncryptUpdate (3,859 samples, 9.94%)</title><rect x="30.4664%" y="421" width="9.9374%" height="15" fill="rgb(221,13,50)" fg:x="11831" fg:w="3859"/><text x="30.7164%" y="431.50">EVP_EncryptUpd..</text></g><g><title>[libcrypto.so.3] (3,809 samples, 9.81%)</title><rect x="30.5951%" y="405" width="9.8087%" height="15" fill="rgb(236,68,49)" fg:x="11881" fg:w="3809"/><text x="30.8451%" y="415.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,805 samples, 9.80%)</title><rect x="30.6054%" y="389" width="9.7984%" height="15" fill="rgb(229,146,28)" fg:x="11885" fg:w="3805"/><text x="30.8554%" y="399.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,789 samples, 9.76%)</title><rect x="30.6466%" y="373" width="9.7572%" height="15" fill="rgb(225,31,38)" fg:x="11901" fg:w="3789"/><text x="30.8966%" y="383.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (2,964 samples, 7.63%)</title><rect x="32.7711%" y="357" width="7.6327%" height="15" fill="rgb(250,208,3)" fg:x="12726" fg:w="2964"/><text x="33.0211%" y="367.50">[libcrypto..</text></g><g><title>[libcrypto.so.3] (2,713 samples, 6.99%)</title><rect x="33.4175%" y="341" width="6.9863%" height="15" fill="rgb(246,54,23)" fg:x="12977" fg:w="2713"/><text x="33.6675%" y="351.50">[libcrypt..</text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="40.3909%" y="325" width="0.0129%" height="15" fill="rgb(243,76,11)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="40.3909%" y="309" width="0.0129%" height="15" fill="rgb(245,21,50)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="40.3909%" y="293" width="0.0129%" height="15" fill="rgb(228,9,43)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="40.3909%" y="277" width="0.0129%" height="15" fill="rgb(208,100,47)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="40.3909%" y="261" width="0.0129%" height="15" fill="rgb(232,26,8)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="40.3909%" y="245" width="0.0129%" height="15" fill="rgb(216,166,38)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="40.3909%" y="229" width="0.0129%" height="15" fill="rgb(251,202,51)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="40.3909%" y="213" width="0.0129%" height="15" fill="rgb(254,216,34)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="40.3909%" y="197" width="0.0129%" height="15" fill="rgb(251,32,27)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="40.3909%" y="181" width="0.0129%" height="15" fill="rgb(208,127,28)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="191.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="40.3909%" y="165" width="0.0129%" height="15" fill="rgb(224,137,22)" fg:x="15685" fg:w="5"/><text x="40.6409%" y="175.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc&gt; (7 samples, 0.02%)</title><rect x="40.4064%" y="437" width="0.0180%" height="15" fill="rgb(254,70,32)" fg:x="15691" fg:w="7"/><text x="40.6564%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (7 samples, 0.02%)</title><rect x="40.4064%" y="421" width="0.0180%" height="15" fill="rgb(229,75,37)" fg:x="15691" fg:w="7"/><text x="40.6564%" y="431.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="40.4064%" y="405" width="0.0180%" height="15" fill="rgb(252,64,23)" fg:x="15691" fg:w="7"/><text x="40.6564%" y="415.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (6 samples, 0.02%)</title><rect x="40.4089%" y="389" width="0.0155%" height="15" fill="rgb(232,162,48)" fg:x="15692" fg:w="6"/><text x="40.6589%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (6 samples, 0.02%)</title><rect x="40.4089%" y="373" width="0.0155%" height="15" fill="rgb(246,160,12)" fg:x="15692" fg:w="6"/><text x="40.6589%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_swap (6 samples, 0.02%)</title><rect x="40.4089%" y="357" width="0.0155%" height="15" fill="rgb(247,166,0)" fg:x="15692" fg:w="6"/><text x="40.6589%" y="367.50"></text></g><g><title>[libcrypto.so.3] (31 samples, 0.08%)</title><rect x="40.5300%" y="325" width="0.0798%" height="15" fill="rgb(249,219,21)" fg:x="15739" fg:w="31"/><text x="40.7800%" y="335.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (75 samples, 0.19%)</title><rect x="40.4244%" y="437" width="0.1931%" height="15" fill="rgb(205,209,3)" fg:x="15698" fg:w="75"/><text x="40.6744%" y="447.50"></text></g><g><title>EVP_EncryptFinal_ex (75 samples, 0.19%)</title><rect x="40.4244%" y="421" width="0.1931%" height="15" fill="rgb(243,44,1)" fg:x="15698" fg:w="75"/><text x="40.6744%" y="431.50"></text></g><g><title>[libcrypto.so.3] (61 samples, 0.16%)</title><rect x="40.4604%" y="405" width="0.1571%" height="15" fill="rgb(206,159,16)" fg:x="15712" fg:w="61"/><text x="40.7104%" y="415.50"></text></g><g><title>[libcrypto.so.3] (59 samples, 0.15%)</title><rect x="40.4656%" y="389" width="0.1519%" height="15" fill="rgb(244,77,30)" fg:x="15714" fg:w="59"/><text x="40.7156%" y="399.50"></text></g><g><title>[libcrypto.so.3] (56 samples, 0.14%)</title><rect x="40.4733%" y="373" width="0.1442%" height="15" fill="rgb(218,69,12)" fg:x="15717" fg:w="56"/><text x="40.7233%" y="383.50"></text></g><g><title>CRYPTO_gcm128_tag (55 samples, 0.14%)</title><rect x="40.4759%" y="357" width="0.1416%" height="15" fill="rgb(212,87,7)" fg:x="15718" fg:w="55"/><text x="40.7259%" y="367.50"></text></g><g><title>CRYPTO_gcm128_finish (42 samples, 0.11%)</title><rect x="40.5094%" y="341" width="0.1082%" height="15" fill="rgb(245,114,25)" fg:x="15731" fg:w="42"/><text x="40.7594%" y="351.50"></text></g><g><title>[libc.so.6] (29 samples, 0.07%)</title><rect x="40.7694%" y="373" width="0.0747%" height="15" fill="rgb(210,61,42)" fg:x="15832" fg:w="29"/><text x="41.0194%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (60 samples, 0.15%)</title><rect x="40.6922%" y="389" width="0.1545%" height="15" fill="rgb(211,52,33)" fg:x="15802" fg:w="60"/><text x="40.9422%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::finish (177 samples, 0.46%)</title><rect x="40.4038%" y="453" width="0.4558%" height="15" fill="rgb(234,58,33)" fg:x="15690" fg:w="177"/><text x="40.6538%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::get_tag (94 samples, 0.24%)</title><rect x="40.6175%" y="437" width="0.2421%" height="15" fill="rgb(220,115,36)" fg:x="15773" fg:w="94"/><text x="40.8675%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (94 samples, 0.24%)</title><rect x="40.6175%" y="421" width="0.2421%" height="15" fill="rgb(243,153,54)" fg:x="15773" fg:w="94"/><text x="40.8675%" y="431.50"></text></g><g><title>[libcrypto.so.3] (69 samples, 0.18%)</title><rect x="40.6819%" y="405" width="0.1777%" height="15" fill="rgb(251,47,18)" fg:x="15798" fg:w="69"/><text x="40.9319%" y="415.50"></text></g><g><title>OSSL_PARAM_set_octet_string (5 samples, 0.01%)</title><rect x="40.8467%" y="389" width="0.0129%" height="15" fill="rgb(242,102,42)" fg:x="15862" fg:w="5"/><text x="41.0967%" y="399.50"></text></g><g><title>[libc.so.6] (5 samples, 0.01%)</title><rect x="40.8467%" y="373" width="0.0129%" height="15" fill="rgb(234,31,38)" fg:x="15862" fg:w="5"/><text x="41.0967%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (15 samples, 0.04%)</title><rect x="40.8596%" y="437" width="0.0386%" height="15" fill="rgb(221,117,51)" fg:x="15867" fg:w="15"/><text x="41.1096%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (13 samples, 0.03%)</title><rect x="40.8647%" y="421" width="0.0335%" height="15" fill="rgb(212,20,18)" fg:x="15869" fg:w="13"/><text x="41.1147%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (11 samples, 0.03%)</title><rect x="40.8699%" y="405" width="0.0283%" height="15" fill="rgb(245,133,36)" fg:x="15871" fg:w="11"/><text x="41.1199%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (11 samples, 0.03%)</title><rect x="40.8699%" y="389" width="0.0283%" height="15" fill="rgb(212,6,19)" fg:x="15871" fg:w="11"/><text x="41.1199%" y="399.50"></text></g><g><title>[libc.so.6] (25 samples, 0.06%)</title><rect x="41.1016%" y="341" width="0.0644%" height="15" fill="rgb(218,1,36)" fg:x="15961" fg:w="25"/><text x="41.3516%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (76 samples, 0.20%)</title><rect x="40.9755%" y="389" width="0.1957%" height="15" fill="rgb(246,84,54)" fg:x="15912" fg:w="76"/><text x="41.2255%" y="399.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="41.0347%" y="373" width="0.1365%" height="15" fill="rgb(242,110,6)" fg:x="15935" fg:w="53"/><text x="41.2847%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (46 samples, 0.12%)</title><rect x="41.0527%" y="357" width="0.1185%" height="15" fill="rgb(214,47,5)" fg:x="15942" fg:w="46"/><text x="41.3027%" y="367.50"></text></g><g><title>[libc.so.6] (37 samples, 0.10%)</title><rect x="41.2948%" y="341" width="0.0953%" height="15" fill="rgb(218,159,25)" fg:x="16036" fg:w="37"/><text x="41.5448%" y="351.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="41.3772%" y="325" width="0.0129%" height="15" fill="rgb(215,211,28)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="41.3772%" y="309" width="0.0129%" height="15" fill="rgb(238,59,32)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="319.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="41.3772%" y="293" width="0.0129%" height="15" fill="rgb(226,82,3)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="41.3772%" y="277" width="0.0129%" height="15" fill="rgb(240,164,32)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="41.3772%" y="261" width="0.0129%" height="15" fill="rgb(232,46,7)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="41.3772%" y="245" width="0.0129%" height="15" fill="rgb(229,129,53)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="255.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="41.3772%" y="229" width="0.0129%" height="15" fill="rgb(234,188,29)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="239.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="41.3772%" y="213" width="0.0129%" height="15" fill="rgb(246,141,4)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="41.3772%" y="197" width="0.0129%" height="15" fill="rgb(229,23,39)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="41.3772%" y="181" width="0.0129%" height="15" fill="rgb(206,12,3)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="191.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="41.3772%" y="165" width="0.0129%" height="15" fill="rgb(252,226,20)" fg:x="16068" fg:w="5"/><text x="41.6272%" y="175.50"></text></g><g><title>OSSL_PARAM_locate (49 samples, 0.13%)</title><rect x="41.2767%" y="357" width="0.1262%" height="15" fill="rgb(216,123,35)" fg:x="16029" fg:w="49"/><text x="41.5267%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="41.3901%" y="341" width="0.0129%" height="15" fill="rgb(212,68,40)" fg:x="16073" fg:w="5"/><text x="41.6401%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (95 samples, 0.24%)</title><rect x="41.1712%" y="389" width="0.2446%" height="15" fill="rgb(254,125,32)" fg:x="15988" fg:w="95"/><text x="41.4212%" y="399.50"></text></g><g><title>[libcrypto.so.3] (62 samples, 0.16%)</title><rect x="41.2561%" y="373" width="0.1597%" height="15" fill="rgb(253,97,22)" fg:x="16021" fg:w="62"/><text x="41.5061%" y="383.50"></text></g><g><title>OSSL_PARAM_locate_const (5 samples, 0.01%)</title><rect x="41.4029%" y="357" width="0.0129%" height="15" fill="rgb(241,101,14)" fg:x="16078" fg:w="5"/><text x="41.6529%" y="367.50"></text></g><g><title>EVP_CIPHER_free (14 samples, 0.04%)</title><rect x="41.4158%" y="389" width="0.0361%" height="15" fill="rgb(238,103,29)" fg:x="16083" fg:w="14"/><text x="41.6658%" y="399.50"></text></g><g><title>EVP_CIPHER_up_ref (28 samples, 0.07%)</title><rect x="41.4519%" y="389" width="0.0721%" height="15" fill="rgb(233,195,47)" fg:x="16097" fg:w="28"/><text x="41.7019%" y="399.50"></text></g><g><title>EVP_CipherInit_ex (245 samples, 0.63%)</title><rect x="40.8982%" y="421" width="0.6309%" height="15" fill="rgb(246,218,30)" fg:x="15882" fg:w="245"/><text x="41.1482%" y="431.50"></text></g><g><title>[libcrypto.so.3] (245 samples, 0.63%)</title><rect x="40.8982%" y="405" width="0.6309%" height="15" fill="rgb(219,145,47)" fg:x="15882" fg:w="245"/><text x="41.1482%" y="415.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (262 samples, 0.67%)</title><rect x="40.8596%" y="453" width="0.6747%" height="15" fill="rgb(243,12,26)" fg:x="15867" fg:w="262"/><text x="41.1096%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (247 samples, 0.64%)</title><rect x="40.8982%" y="437" width="0.6361%" height="15" fill="rgb(214,87,16)" fg:x="15882" fg:w="247"/><text x="41.1482%" y="447.50"></text></g><g><title>__rdl_alloc (10 samples, 0.03%)</title><rect x="41.5420%" y="277" width="0.0258%" height="15" fill="rgb(208,99,42)" fg:x="16132" fg:w="10"/><text x="41.7920%" y="287.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::alloc (10 samples, 0.03%)</title><rect x="41.5420%" y="261" width="0.0258%" height="15" fill="rgb(253,99,2)" fg:x="16132" fg:w="10"/><text x="41.7920%" y="271.50"></text></g><g><title>__rust_alloc (5 samples, 0.01%)</title><rect x="41.5677%" y="277" width="0.0129%" height="15" fill="rgb(220,168,23)" fg:x="16142" fg:w="5"/><text x="41.8177%" y="287.50"></text></g><g><title>[libc.so.6] (74 samples, 0.19%)</title><rect x="46.1489%" y="245" width="0.1906%" height="15" fill="rgb(242,38,24)" fg:x="17921" fg:w="74"/><text x="46.3989%" y="255.50"></text></g><g><title>asm_exc_page_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="229" width="0.0129%" height="15" fill="rgb(225,182,9)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="239.50"></text></g><g><title>exc_page_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="213" width="0.0129%" height="15" fill="rgb(243,178,37)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="223.50"></text></g><g><title>do_user_addr_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="197" width="0.0129%" height="15" fill="rgb(232,139,19)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="207.50"></text></g><g><title>handle_mm_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="181" width="0.0129%" height="15" fill="rgb(225,201,24)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="191.50"></text></g><g><title>__handle_mm_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="165" width="0.0129%" height="15" fill="rgb(221,47,46)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="175.50"></text></g><g><title>handle_pte_fault (5 samples, 0.01%)</title><rect x="46.3266%" y="149" width="0.0129%" height="15" fill="rgb(249,23,13)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="159.50"></text></g><g><title>do_anonymous_page (5 samples, 0.01%)</title><rect x="46.3266%" y="133" width="0.0129%" height="15" fill="rgb(219,9,5)" fg:x="17990" fg:w="5"/><text x="46.5766%" y="143.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="46.3446%" y="85" width="0.0129%" height="15" fill="rgb(254,171,16)" fg:x="17997" fg:w="5"/><text x="46.5946%" y="95.50"></text></g><g><title>finish_task_switch.isra.0 (13 samples, 0.03%)</title><rect x="46.3446%" y="117" width="0.0335%" height="15" fill="rgb(230,171,20)" fg:x="17997" fg:w="13"/><text x="46.5946%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (13 samples, 0.03%)</title><rect x="46.3446%" y="101" width="0.0335%" height="15" fill="rgb(210,71,41)" fg:x="17997" fg:w="13"/><text x="46.5946%" y="111.50"></text></g><g><title>perf_pmu_nop_void (8 samples, 0.02%)</title><rect x="46.3575%" y="85" width="0.0206%" height="15" fill="rgb(206,173,20)" fg:x="18002" fg:w="8"/><text x="46.6075%" y="95.50"></text></g><g><title>[libc.so.6] (1,111 samples, 2.86%)</title><rect x="43.5197%" y="261" width="2.8610%" height="15" fill="rgb(233,88,34)" fg:x="16900" fg:w="1111"/><text x="43.7697%" y="271.50">[l..</text></g><g><title>asm_sysvec_reschedule_ipi (16 samples, 0.04%)</title><rect x="46.3395%" y="245" width="0.0412%" height="15" fill="rgb(223,209,46)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="255.50"></text></g><g><title>sysvec_reschedule_ipi (16 samples, 0.04%)</title><rect x="46.3395%" y="229" width="0.0412%" height="15" fill="rgb(250,43,18)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="239.50"></text></g><g><title>irqentry_exit (16 samples, 0.04%)</title><rect x="46.3395%" y="213" width="0.0412%" height="15" fill="rgb(208,13,10)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="223.50"></text></g><g><title>irqentry_exit_to_user_mode (16 samples, 0.04%)</title><rect x="46.3395%" y="197" width="0.0412%" height="15" fill="rgb(212,200,36)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (16 samples, 0.04%)</title><rect x="46.3395%" y="181" width="0.0412%" height="15" fill="rgb(225,90,30)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="191.50"></text></g><g><title>exit_to_user_mode_loop (16 samples, 0.04%)</title><rect x="46.3395%" y="165" width="0.0412%" height="15" fill="rgb(236,182,39)" fg:x="17995" fg:w="16"/><text x="46.5895%" y="175.50"></text></g><g><title>schedule (14 samples, 0.04%)</title><rect x="46.3446%" y="149" width="0.0361%" height="15" fill="rgb(212,144,35)" fg:x="17997" fg:w="14"/><text x="46.5946%" y="159.50"></text></g><g><title>__schedule (14 samples, 0.04%)</title><rect x="46.3446%" y="133" width="0.0361%" height="15" fill="rgb(228,63,44)" fg:x="17997" fg:w="14"/><text x="46.5946%" y="143.50"></text></g><g><title>__entry_text_start (10 samples, 0.03%)</title><rect x="46.4502%" y="245" width="0.0258%" height="15" fill="rgb(228,109,6)" fg:x="18038" fg:w="10"/><text x="46.7002%" y="255.50"></text></g><g><title>__get_user_nocheck_4 (9 samples, 0.02%)</title><rect x="46.5120%" y="149" width="0.0232%" height="15" fill="rgb(238,117,24)" fg:x="18062" fg:w="9"/><text x="46.7620%" y="159.50"></text></g><g><title>_raw_spin_lock (6 samples, 0.02%)</title><rect x="46.5352%" y="149" width="0.0155%" height="15" fill="rgb(242,26,26)" fg:x="18071" fg:w="6"/><text x="46.7852%" y="159.50"></text></g><g><title>futex_q_lock (10 samples, 0.03%)</title><rect x="46.5583%" y="149" width="0.0258%" height="15" fill="rgb(221,92,48)" fg:x="18080" fg:w="10"/><text x="46.8083%" y="159.50"></text></g><g><title>futex_q_unlock (12 samples, 0.03%)</title><rect x="46.5841%" y="149" width="0.0309%" height="15" fill="rgb(209,209,32)" fg:x="18090" fg:w="12"/><text x="46.8341%" y="159.50"></text></g><g><title>futex_wait_setup (44 samples, 0.11%)</title><rect x="46.5120%" y="165" width="0.1133%" height="15" fill="rgb(221,70,22)" fg:x="18062" fg:w="44"/><text x="46.7620%" y="175.50"></text></g><g><title>get_futex_key (4 samples, 0.01%)</title><rect x="46.6150%" y="149" width="0.0103%" height="15" fill="rgb(248,145,5)" fg:x="18102" fg:w="4"/><text x="46.8650%" y="159.50"></text></g><g><title>futex_wait (52 samples, 0.13%)</title><rect x="46.4940%" y="181" width="0.1339%" height="15" fill="rgb(226,116,26)" fg:x="18055" fg:w="52"/><text x="46.7440%" y="191.50"></text></g><g><title>__x64_sys_futex (57 samples, 0.15%)</title><rect x="46.4837%" y="213" width="0.1468%" height="15" fill="rgb(244,5,17)" fg:x="18051" fg:w="57"/><text x="46.7337%" y="223.50"></text></g><g><title>do_futex (54 samples, 0.14%)</title><rect x="46.4914%" y="197" width="0.1391%" height="15" fill="rgb(252,159,33)" fg:x="18054" fg:w="54"/><text x="46.7414%" y="207.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (62 samples, 0.16%)</title><rect x="46.4785%" y="245" width="0.1597%" height="15" fill="rgb(206,71,0)" fg:x="18049" fg:w="62"/><text x="46.7285%" y="255.50"></text></g><g><title>do_syscall_64 (60 samples, 0.15%)</title><rect x="46.4837%" y="229" width="0.1545%" height="15" fill="rgb(233,118,54)" fg:x="18051" fg:w="60"/><text x="46.7337%" y="239.50"></text></g><g><title>__lll_lock_wait_private (101 samples, 0.26%)</title><rect x="46.3807%" y="261" width="0.2601%" height="15" fill="rgb(234,83,48)" fg:x="18011" fg:w="101"/><text x="46.6307%" y="271.50"></text></g><g><title>__entry_text_start (7 samples, 0.02%)</title><rect x="46.6536%" y="245" width="0.0180%" height="15" fill="rgb(228,3,54)" fg:x="18117" fg:w="7"/><text x="46.9036%" y="255.50"></text></g><g><title>_raw_spin_lock (9 samples, 0.02%)</title><rect x="46.7000%" y="181" width="0.0232%" height="15" fill="rgb(226,155,13)" fg:x="18135" fg:w="9"/><text x="46.9500%" y="191.50"></text></g><g><title>_raw_spin_lock (12 samples, 0.03%)</title><rect x="46.8880%" y="165" width="0.0309%" height="15" fill="rgb(241,28,37)" fg:x="18208" fg:w="12"/><text x="47.1380%" y="175.50"></text></g><g><title>native_queued_spin_lock_slowpath (12 samples, 0.03%)</title><rect x="46.8880%" y="149" width="0.0309%" height="15" fill="rgb(233,93,10)" fg:x="18208" fg:w="12"/><text x="47.1380%" y="159.50"></text></g><g><title>futex_wake_mark (24 samples, 0.06%)</title><rect x="46.9189%" y="165" width="0.0618%" height="15" fill="rgb(225,113,19)" fg:x="18220" fg:w="24"/><text x="47.1689%" y="175.50"></text></g><g><title>__futex_unqueue (4 samples, 0.01%)</title><rect x="46.9704%" y="149" width="0.0103%" height="15" fill="rgb(241,2,18)" fg:x="18240" fg:w="4"/><text x="47.2204%" y="159.50"></text></g><g><title>__smp_call_single_queue (20 samples, 0.05%)</title><rect x="47.1223%" y="117" width="0.0515%" height="15" fill="rgb(228,207,21)" fg:x="18299" fg:w="20"/><text x="47.3723%" y="127.50"></text></g><g><title>native_send_call_func_single_ipi (17 samples, 0.04%)</title><rect x="47.1300%" y="101" width="0.0438%" height="15" fill="rgb(213,211,35)" fg:x="18302" fg:w="17"/><text x="47.3800%" y="111.50"></text></g><g><title>x2apic_send_IPI (17 samples, 0.04%)</title><rect x="47.1300%" y="85" width="0.0438%" height="15" fill="rgb(209,83,10)" fg:x="18302" fg:w="17"/><text x="47.3800%" y="95.50"></text></g><g><title>native_write_msr (15 samples, 0.04%)</title><rect x="47.1352%" y="69" width="0.0386%" height="15" fill="rgb(209,164,1)" fg:x="18304" fg:w="15"/><text x="47.3852%" y="79.50"></text></g><g><title>llist_add_batch (17 samples, 0.04%)</title><rect x="47.1764%" y="117" width="0.0438%" height="15" fill="rgb(213,184,43)" fg:x="18320" fg:w="17"/><text x="47.4264%" y="127.50"></text></g><g><title>try_to_wake_up (89 samples, 0.23%)</title><rect x="47.0013%" y="149" width="0.2292%" height="15" fill="rgb(231,61,34)" fg:x="18252" fg:w="89"/><text x="47.2513%" y="159.50"></text></g><g><title>ttwu_queue_wakelist (55 samples, 0.14%)</title><rect x="47.0888%" y="133" width="0.1416%" height="15" fill="rgb(235,75,3)" fg:x="18286" fg:w="55"/><text x="47.3388%" y="143.50"></text></g><g><title>futex_wake (196 samples, 0.50%)</title><rect x="46.7283%" y="181" width="0.5047%" height="15" fill="rgb(220,106,47)" fg:x="18146" fg:w="196"/><text x="46.9783%" y="191.50"></text></g><g><title>wake_up_q (96 samples, 0.25%)</title><rect x="46.9858%" y="165" width="0.2472%" height="15" fill="rgb(210,196,33)" fg:x="18246" fg:w="96"/><text x="47.2358%" y="175.50"></text></g><g><title>do_futex (210 samples, 0.54%)</title><rect x="46.6948%" y="197" width="0.5408%" height="15" fill="rgb(229,154,42)" fg:x="18133" fg:w="210"/><text x="46.9448%" y="207.50"></text></g><g><title>__x64_sys_futex (214 samples, 0.55%)</title><rect x="46.6897%" y="213" width="0.5511%" height="15" fill="rgb(228,114,26)" fg:x="18131" fg:w="214"/><text x="46.9397%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (224 samples, 0.58%)</title><rect x="46.6768%" y="245" width="0.5768%" height="15" fill="rgb(208,144,1)" fg:x="18126" fg:w="224"/><text x="46.9268%" y="255.50"></text></g><g><title>do_syscall_64 (222 samples, 0.57%)</title><rect x="46.6819%" y="229" width="0.5717%" height="15" fill="rgb(239,112,37)" fg:x="18128" fg:w="222"/><text x="46.9319%" y="239.50"></text></g><g><title>__lll_lock_wake_private (239 samples, 0.62%)</title><rect x="46.6407%" y="261" width="0.6155%" height="15" fill="rgb(210,96,50)" fg:x="18112" fg:w="239"/><text x="46.8907%" y="271.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (2,224 samples, 5.73%)</title><rect x="41.5343%" y="373" width="5.7271%" height="15" fill="rgb(222,178,2)" fg:x="16129" fg:w="2224"/><text x="41.7843%" y="383.50">alloc::..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (2,224 samples, 5.73%)</title><rect x="41.5343%" y="357" width="5.7271%" height="15" fill="rgb(226,74,18)" fg:x="16129" fg:w="2224"/><text x="41.7843%" y="367.50">alloc::..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (2,224 samples, 5.73%)</title><rect x="41.5343%" y="341" width="5.7271%" height="15" fill="rgb(225,67,54)" fg:x="16129" fg:w="2224"/><text x="41.7843%" y="351.50">alloc::..</text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (2,221 samples, 5.72%)</title><rect x="41.5420%" y="325" width="5.7194%" height="15" fill="rgb(251,92,32)" fg:x="16132" fg:w="2221"/><text x="41.7920%" y="335.50">&lt;alloc:..</text></g><g><title>alloc::alloc::Global::alloc_impl (2,221 samples, 5.72%)</title><rect x="41.5420%" y="309" width="5.7194%" height="15" fill="rgb(228,149,22)" fg:x="16132" fg:w="2221"/><text x="41.7920%" y="319.50">alloc::..</text></g><g><title>alloc::alloc::alloc (2,221 samples, 5.72%)</title><rect x="41.5420%" y="293" width="5.7194%" height="15" fill="rgb(243,54,13)" fg:x="16132" fg:w="2221"/><text x="41.7920%" y="303.50">alloc::..</text></g><g><title>malloc (2,206 samples, 5.68%)</title><rect x="41.5806%" y="277" width="5.6807%" height="15" fill="rgb(243,180,28)" fg:x="16147" fg:w="2206"/><text x="41.8306%" y="287.50">malloc</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (2,451 samples, 6.31%)</title><rect x="41.5343%" y="437" width="6.3116%" height="15" fill="rgb(208,167,24)" fg:x="16129" fg:w="2451"/><text x="41.7843%" y="447.50">alloc::s..</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (2,451 samples, 6.31%)</title><rect x="41.5343%" y="421" width="6.3116%" height="15" fill="rgb(245,73,45)" fg:x="16129" fg:w="2451"/><text x="41.7843%" y="431.50">alloc::s..</text></g><g><title>alloc::slice::hack::to_vec (2,451 samples, 6.31%)</title><rect x="41.5343%" y="405" width="6.3116%" height="15" fill="rgb(237,203,48)" fg:x="16129" fg:w="2451"/><text x="41.7843%" y="415.50">alloc::s..</text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (2,451 samples, 6.31%)</title><rect x="41.5343%" y="389" width="6.3116%" height="15" fill="rgb(211,197,16)" fg:x="16129" fg:w="2451"/><text x="41.7843%" y="399.50">&lt;T as al..</text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (227 samples, 0.58%)</title><rect x="47.2613%" y="373" width="0.5846%" height="15" fill="rgb(243,99,51)" fg:x="18353" fg:w="227"/><text x="47.5113%" y="383.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (227 samples, 0.58%)</title><rect x="47.2613%" y="357" width="0.5846%" height="15" fill="rgb(215,123,29)" fg:x="18353" fg:w="227"/><text x="47.5113%" y="367.50"></text></g><g><title>[libc.so.6] (222 samples, 0.57%)</title><rect x="47.2742%" y="341" width="0.5717%" height="15" fill="rgb(239,186,37)" fg:x="18358" fg:w="222"/><text x="47.5242%" y="351.50"></text></g><g><title>&lt;std::sync::mpmc::select::Token as core::default::Default&gt;::default (5 samples, 0.01%)</title><rect x="51.3790%" y="389" width="0.0129%" height="15" fill="rgb(252,136,39)" fg:x="19952" fg:w="5"/><text x="51.6290%" y="399.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (4 samples, 0.01%)</title><rect x="51.3944%" y="389" width="0.0103%" height="15" fill="rgb(223,213,32)" fg:x="19958" fg:w="4"/><text x="51.6444%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (80 samples, 0.21%)</title><rect x="51.4717%" y="373" width="0.2060%" height="15" fill="rgb(233,115,5)" fg:x="19988" fg:w="80"/><text x="51.7217%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (80 samples, 0.21%)</title><rect x="51.4717%" y="357" width="0.2060%" height="15" fill="rgb(207,226,44)" fg:x="19988" fg:w="80"/><text x="51.7217%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (113 samples, 0.29%)</title><rect x="51.4047%" y="389" width="0.2910%" height="15" fill="rgb(208,126,0)" fg:x="19962" fg:w="113"/><text x="51.6547%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (7 samples, 0.02%)</title><rect x="51.6777%" y="373" width="0.0180%" height="15" fill="rgb(244,66,21)" fg:x="20068" fg:w="7"/><text x="51.9277%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (7 samples, 0.02%)</title><rect x="51.6777%" y="357" width="0.0180%" height="15" fill="rgb(222,97,12)" fg:x="20068" fg:w="7"/><text x="51.9277%" y="367.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (6 samples, 0.02%)</title><rect x="51.7447%" y="261" width="0.0155%" height="15" fill="rgb(219,213,19)" fg:x="20094" fg:w="6"/><text x="51.9947%" y="271.50"></text></g><g><title>core::sync::atomic::atomic_swap (6 samples, 0.02%)</title><rect x="51.7447%" y="245" width="0.0155%" height="15" fill="rgb(252,169,30)" fg:x="20094" fg:w="6"/><text x="51.9947%" y="255.50"></text></g><g><title>futex_wake_mark (7 samples, 0.02%)</title><rect x="51.8090%" y="149" width="0.0180%" height="15" fill="rgb(206,32,51)" fg:x="20119" fg:w="7"/><text x="52.0590%" y="159.50"></text></g><g><title>__smp_call_single_queue (6 samples, 0.02%)</title><rect x="51.8966%" y="101" width="0.0155%" height="15" fill="rgb(250,172,42)" fg:x="20153" fg:w="6"/><text x="52.1466%" y="111.50"></text></g><g><title>__x64_sys_futex (57 samples, 0.15%)</title><rect x="51.7730%" y="197" width="0.1468%" height="15" fill="rgb(209,34,43)" fg:x="20105" fg:w="57"/><text x="52.0230%" y="207.50"></text></g><g><title>do_futex (57 samples, 0.15%)</title><rect x="51.7730%" y="181" width="0.1468%" height="15" fill="rgb(223,11,35)" fg:x="20105" fg:w="57"/><text x="52.0230%" y="191.50"></text></g><g><title>futex_wake (55 samples, 0.14%)</title><rect x="51.7781%" y="165" width="0.1416%" height="15" fill="rgb(251,219,26)" fg:x="20107" fg:w="55"/><text x="52.0281%" y="175.50"></text></g><g><title>wake_up_q (36 samples, 0.09%)</title><rect x="51.8271%" y="149" width="0.0927%" height="15" fill="rgb(231,119,3)" fg:x="20126" fg:w="36"/><text x="52.0771%" y="159.50"></text></g><g><title>try_to_wake_up (35 samples, 0.09%)</title><rect x="51.8296%" y="133" width="0.0901%" height="15" fill="rgb(216,97,11)" fg:x="20127" fg:w="35"/><text x="52.0796%" y="143.50"></text></g><g><title>ttwu_queue_wakelist (14 samples, 0.04%)</title><rect x="51.8837%" y="117" width="0.0361%" height="15" fill="rgb(223,59,9)" fg:x="20148" fg:w="14"/><text x="52.1337%" y="127.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (91 samples, 0.23%)</title><rect x="51.6957%" y="389" width="0.2343%" height="15" fill="rgb(233,93,31)" fg:x="20075" fg:w="91"/><text x="51.9457%" y="399.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (85 samples, 0.22%)</title><rect x="51.7112%" y="373" width="0.2189%" height="15" fill="rgb(239,81,33)" fg:x="20081" fg:w="85"/><text x="51.9612%" y="383.50"></text></g><g><title>std::sync::mpmc::waker::Waker::try_select (74 samples, 0.19%)</title><rect x="51.7395%" y="357" width="0.1906%" height="15" fill="rgb(213,120,34)" fg:x="20092" fg:w="74"/><text x="51.9895%" y="367.50"></text></g><g><title>&lt;core::slice::iter::Iter&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::position (74 samples, 0.19%)</title><rect x="51.7395%" y="341" width="0.1906%" height="15" fill="rgb(243,49,53)" fg:x="20092" fg:w="74"/><text x="51.9895%" y="351.50"></text></g><g><title>std::sync::mpmc::waker::Waker::try_select::_{{closure}} (74 samples, 0.19%)</title><rect x="51.7395%" y="325" width="0.1906%" height="15" fill="rgb(247,216,33)" fg:x="20092" fg:w="74"/><text x="51.9895%" y="335.50"></text></g><g><title>std::sync::mpmc::context::Context::unpark (72 samples, 0.19%)</title><rect x="51.7447%" y="309" width="0.1854%" height="15" fill="rgb(226,26,14)" fg:x="20094" fg:w="72"/><text x="51.9947%" y="319.50"></text></g><g><title>std::thread::Thread::unpark (72 samples, 0.19%)</title><rect x="51.7447%" y="293" width="0.1854%" height="15" fill="rgb(215,49,53)" fg:x="20094" fg:w="72"/><text x="51.9947%" y="303.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::unpark (72 samples, 0.19%)</title><rect x="51.7447%" y="277" width="0.1854%" height="15" fill="rgb(245,162,40)" fg:x="20094" fg:w="72"/><text x="51.9947%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wake (66 samples, 0.17%)</title><rect x="51.7601%" y="261" width="0.1700%" height="15" fill="rgb(229,68,17)" fg:x="20100" fg:w="66"/><text x="52.0101%" y="271.50"></text></g><g><title>syscall (66 samples, 0.17%)</title><rect x="51.7601%" y="245" width="0.1700%" height="15" fill="rgb(213,182,10)" fg:x="20100" fg:w="66"/><text x="52.0101%" y="255.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (61 samples, 0.16%)</title><rect x="51.7730%" y="229" width="0.1571%" height="15" fill="rgb(245,125,30)" fg:x="20105" fg:w="61"/><text x="52.0230%" y="239.50"></text></g><g><title>do_syscall_64 (61 samples, 0.16%)</title><rect x="51.7730%" y="213" width="0.1571%" height="15" fill="rgb(232,202,2)" fg:x="20105" fg:w="61"/><text x="52.0230%" y="223.50"></text></g><g><title>std::sync::mpmc::context::Context::wait_until (4 samples, 0.01%)</title><rect x="51.9301%" y="309" width="0.0103%" height="15" fill="rgb(237,140,51)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="319.50"></text></g><g><title>std::thread::park (4 samples, 0.01%)</title><rect x="51.9301%" y="293" width="0.0103%" height="15" fill="rgb(236,157,25)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="303.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::park (4 samples, 0.01%)</title><rect x="51.9301%" y="277" width="0.0103%" height="15" fill="rgb(219,209,0)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wait (4 samples, 0.01%)</title><rect x="51.9301%" y="261" width="0.0103%" height="15" fill="rgb(240,116,54)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="271.50"></text></g><g><title>syscall (4 samples, 0.01%)</title><rect x="51.9301%" y="245" width="0.0103%" height="15" fill="rgb(216,10,36)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="255.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (4 samples, 0.01%)</title><rect x="51.9301%" y="229" width="0.0103%" height="15" fill="rgb(222,72,44)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="239.50"></text></g><g><title>do_syscall_64 (4 samples, 0.01%)</title><rect x="51.9301%" y="213" width="0.0103%" height="15" fill="rgb(232,159,9)" fg:x="20166" fg:w="4"/><text x="52.1801%" y="223.50"></text></g><g><title>std::sync::mpmc::context::Context::with (5 samples, 0.01%)</title><rect x="51.9301%" y="389" width="0.0129%" height="15" fill="rgb(210,39,32)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="399.50"></text></g><g><title>std::thread::local::LocalKey&lt;T&gt;::try_with (5 samples, 0.01%)</title><rect x="51.9301%" y="373" width="0.0129%" height="15" fill="rgb(216,194,45)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="383.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (5 samples, 0.01%)</title><rect x="51.9301%" y="357" width="0.0129%" height="15" fill="rgb(218,18,35)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="367.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (5 samples, 0.01%)</title><rect x="51.9301%" y="341" width="0.0129%" height="15" fill="rgb(207,83,51)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="351.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send::_{{closure}} (5 samples, 0.01%)</title><rect x="51.9301%" y="325" width="0.0129%" height="15" fill="rgb(225,63,43)" fg:x="20166" fg:w="5"/><text x="52.1801%" y="335.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (4,067 samples, 10.47%)</title><rect x="41.5343%" y="453" width="10.4731%" height="15" fill="rgb(207,57,36)" fg:x="16129" fg:w="4067"/><text x="41.7843%" y="463.50">benchmark::bob_..</text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (1,615 samples, 4.16%)</title><rect x="47.8485%" y="437" width="4.1588%" height="15" fill="rgb(216,99,33)" fg:x="18581" fg:w="1615"/><text x="48.0985%" y="447.50">std::..</text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (1,613 samples, 4.15%)</title><rect x="47.8536%" y="421" width="4.1537%" height="15" fill="rgb(225,42,16)" fg:x="18583" fg:w="1613"/><text x="48.1036%" y="431.50">std::..</text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (265 samples, 0.68%)</title><rect x="51.3249%" y="405" width="0.6824%" height="15" fill="rgb(220,201,45)" fg:x="19931" fg:w="265"/><text x="51.5749%" y="415.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::spin_light (25 samples, 0.06%)</title><rect x="51.9429%" y="389" width="0.0644%" height="15" fill="rgb(225,33,4)" fg:x="20171" fg:w="25"/><text x="52.1929%" y="399.50"></text></g><g><title>core::hint::spin_loop (25 samples, 0.06%)</title><rect x="51.9429%" y="373" width="0.0644%" height="15" fill="rgb(224,33,50)" fg:x="20171" fg:w="25"/><text x="52.1929%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_pause (25 samples, 0.06%)</title><rect x="51.9429%" y="357" width="0.0644%" height="15" fill="rgb(246,198,51)" fg:x="20171" fg:w="25"/><text x="52.1929%" y="367.50"></text></g><g><title>core::mem::drop (16 samples, 0.04%)</title><rect x="52.0150%" y="453" width="0.0412%" height="15" fill="rgb(205,22,4)" fg:x="20199" fg:w="16"/><text x="52.2650%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (16 samples, 0.04%)</title><rect x="52.0150%" y="437" width="0.0412%" height="15" fill="rgb(206,3,8)" fg:x="20199" fg:w="16"/><text x="52.2650%" y="447.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (16 samples, 0.04%)</title><rect x="52.0150%" y="421" width="0.0412%" height="15" fill="rgb(251,23,15)" fg:x="20199" fg:w="16"/><text x="52.2650%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (16 samples, 0.04%)</title><rect x="52.0150%" y="405" width="0.0412%" height="15" fill="rgb(252,88,28)" fg:x="20199" fg:w="16"/><text x="52.2650%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (15 samples, 0.04%)</title><rect x="52.0176%" y="389" width="0.0386%" height="15" fill="rgb(212,127,14)" fg:x="20200" fg:w="15"/><text x="52.2676%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_sub (15 samples, 0.04%)</title><rect x="52.0176%" y="373" width="0.0386%" height="15" fill="rgb(247,145,37)" fg:x="20200" fg:w="15"/><text x="52.2676%" y="383.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (6 samples, 0.02%)</title><rect x="52.0562%" y="453" width="0.0155%" height="15" fill="rgb(209,117,53)" fg:x="20215" fg:w="6"/><text x="52.3062%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (6 samples, 0.02%)</title><rect x="52.0562%" y="437" width="0.0155%" height="15" fill="rgb(212,90,42)" fg:x="20215" fg:w="6"/><text x="52.3062%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (4 samples, 0.01%)</title><rect x="52.0768%" y="453" width="0.0103%" height="15" fill="rgb(218,164,37)" fg:x="20223" fg:w="4"/><text x="52.3268%" y="463.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (4 samples, 0.01%)</title><rect x="52.0768%" y="437" width="0.0103%" height="15" fill="rgb(246,65,34)" fg:x="20223" fg:w="4"/><text x="52.3268%" y="447.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (23 samples, 0.06%)</title><rect x="52.0871%" y="453" width="0.0592%" height="15" fill="rgb(231,100,33)" fg:x="20227" fg:w="23"/><text x="52.3371%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (23 samples, 0.06%)</title><rect x="52.0871%" y="437" width="0.0592%" height="15" fill="rgb(228,126,14)" fg:x="20227" fg:w="23"/><text x="52.3371%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (21 samples, 0.05%)</title><rect x="52.0923%" y="421" width="0.0541%" height="15" fill="rgb(215,173,21)" fg:x="20229" fg:w="21"/><text x="52.3423%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (21 samples, 0.05%)</title><rect x="52.0923%" y="405" width="0.0541%" height="15" fill="rgb(210,6,40)" fg:x="20229" fg:w="21"/><text x="52.3423%" y="415.50"></text></g><g><title>benchmark::alice_main (18,418 samples, 47.43%)</title><rect x="4.7640%" y="501" width="47.4287%" height="15" fill="rgb(212,48,18)" fg:x="1850" fg:w="18418"/><text x="5.0140%" y="511.50">benchmark::alice_main</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::send (8,789 samples, 22.63%)</title><rect x="29.5599%" y="485" width="22.6328%" height="15" fill="rgb(230,214,11)" fg:x="11479" fg:w="8789"/><text x="29.8099%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::send</text></g><g><title>zssp::zeta::send_payload (8,789 samples, 22.63%)</title><rect x="29.5599%" y="469" width="22.6328%" height="15" fill="rgb(254,105,39)" fg:x="11479" fg:w="8789"/><text x="29.8099%" y="479.50">zssp::zeta::send_payload</text></g><g><title>zssp::zeta::get_counter (18 samples, 0.05%)</title><rect x="52.1464%" y="453" width="0.0464%" height="15" fill="rgb(245,158,5)" fg:x="20250" fg:w="18"/><text x="52.3964%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_add (16 samples, 0.04%)</title><rect x="52.1515%" y="437" width="0.0412%" height="15" fill="rgb(249,208,11)" fg:x="20252" fg:w="16"/><text x="52.4015%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_add (16 samples, 0.04%)</title><rect x="52.1515%" y="421" width="0.0412%" height="15" fill="rgb(210,39,28)" fg:x="20252" fg:w="16"/><text x="52.4015%" y="431.50"></text></g><g><title>[libc.so.6] (15 samples, 0.04%)</title><rect x="52.2648%" y="485" width="0.0386%" height="15" fill="rgb(211,56,53)" fg:x="20296" fg:w="15"/><text x="52.5148%" y="495.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (15 samples, 0.04%)</title><rect x="52.3112%" y="485" width="0.0386%" height="15" fill="rgb(226,201,30)" fg:x="20314" fg:w="15"/><text x="52.5612%" y="495.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (15 samples, 0.04%)</title><rect x="52.3112%" y="469" width="0.0386%" height="15" fill="rgb(239,101,34)" fg:x="20314" fg:w="15"/><text x="52.5612%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (14 samples, 0.04%)</title><rect x="52.3138%" y="453" width="0.0361%" height="15" fill="rgb(226,209,5)" fg:x="20315" fg:w="14"/><text x="52.5638%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_sub (14 samples, 0.04%)</title><rect x="52.3138%" y="437" width="0.0361%" height="15" fill="rgb(250,105,47)" fg:x="20315" fg:w="14"/><text x="52.5638%" y="447.50"></text></g><g><title>core::time::Duration::as_millis (8 samples, 0.02%)</title><rect x="52.3498%" y="485" width="0.0206%" height="15" fill="rgb(230,72,3)" fg:x="20329" fg:w="8"/><text x="52.5998%" y="495.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map_err (4 samples, 0.01%)</title><rect x="52.4580%" y="421" width="0.0103%" height="15" fill="rgb(232,218,39)" fg:x="20371" fg:w="4"/><text x="52.7080%" y="431.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::read (7 samples, 0.02%)</title><rect x="52.4683%" y="421" width="0.0180%" height="15" fill="rgb(248,166,6)" fg:x="20375" fg:w="7"/><text x="52.7183%" y="431.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (6 samples, 0.02%)</title><rect x="52.4708%" y="405" width="0.0155%" height="15" fill="rgb(247,89,20)" fg:x="20376" fg:w="6"/><text x="52.7208%" y="415.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::get_unchecked (6 samples, 0.02%)</title><rect x="52.5893%" y="405" width="0.0155%" height="15" fill="rgb(248,130,54)" fg:x="20422" fg:w="6"/><text x="52.8393%" y="415.50"></text></g><g><title>&lt;usize as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked (6 samples, 0.02%)</title><rect x="52.5893%" y="389" width="0.0155%" height="15" fill="rgb(234,196,4)" fg:x="20422" fg:w="6"/><text x="52.8393%" y="399.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::add (6 samples, 0.02%)</title><rect x="52.5893%" y="373" width="0.0155%" height="15" fill="rgb(250,143,31)" fg:x="20422" fg:w="6"/><text x="52.8393%" y="383.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::offset (6 samples, 0.02%)</title><rect x="52.5893%" y="357" width="0.0155%" height="15" fill="rgb(211,110,34)" fg:x="20422" fg:w="6"/><text x="52.8393%" y="367.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (90 samples, 0.23%)</title><rect x="52.6047%" y="405" width="0.2318%" height="15" fill="rgb(215,124,48)" fg:x="20428" fg:w="90"/><text x="52.8547%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (90 samples, 0.23%)</title><rect x="52.6047%" y="389" width="0.2318%" height="15" fill="rgb(216,46,13)" fg:x="20428" fg:w="90"/><text x="52.8547%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (63 samples, 0.16%)</title><rect x="52.8365%" y="405" width="0.1622%" height="15" fill="rgb(205,184,25)" fg:x="20518" fg:w="63"/><text x="53.0865%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (63 samples, 0.16%)</title><rect x="52.8365%" y="389" width="0.1622%" height="15" fill="rgb(228,1,10)" fg:x="20518" fg:w="63"/><text x="53.0865%" y="399.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (200 samples, 0.52%)</title><rect x="52.4863%" y="421" width="0.5150%" height="15" fill="rgb(213,116,27)" fg:x="20382" fg:w="200"/><text x="52.7363%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (5 samples, 0.01%)</title><rect x="53.0142%" y="325" width="0.0129%" height="15" fill="rgb(241,95,50)" fg:x="20587" fg:w="5"/><text x="53.2642%" y="335.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="53.0142%" y="309" width="0.0129%" height="15" fill="rgb(238,48,32)" fg:x="20587" fg:w="5"/><text x="53.2642%" y="319.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (4 samples, 0.01%)</title><rect x="53.0322%" y="293" width="0.0103%" height="15" fill="rgb(235,113,49)" fg:x="20594" fg:w="4"/><text x="53.2822%" y="303.50"></text></g><g><title>core::sync::atomic::atomic_swap (4 samples, 0.01%)</title><rect x="53.0322%" y="277" width="0.0103%" height="15" fill="rgb(205,127,43)" fg:x="20594" fg:w="4"/><text x="53.2822%" y="287.50"></text></g><g><title>core::option::Option&lt;T&gt;::and_then (7 samples, 0.02%)</title><rect x="53.0425%" y="277" width="0.0180%" height="15" fill="rgb(250,162,2)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="287.50"></text></g><g><title>std::sys::unix::futex::futex_wait::_{{closure}} (7 samples, 0.02%)</title><rect x="53.0425%" y="261" width="0.0180%" height="15" fill="rgb(220,13,41)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="271.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (7 samples, 0.02%)</title><rect x="53.0425%" y="245" width="0.0180%" height="15" fill="rgb(249,221,25)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="255.50"></text></g><g><title>clock_gettime (7 samples, 0.02%)</title><rect x="53.0425%" y="229" width="0.0180%" height="15" fill="rgb(215,208,19)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="239.50"></text></g><g><title>[[vdso]] (7 samples, 0.02%)</title><rect x="53.0425%" y="213" width="0.0180%" height="15" fill="rgb(236,175,2)" fg:x="20598" fg:w="7"/><text x="53.2925%" y="223.50"></text></g><g><title>[[vdso]] (4 samples, 0.01%)</title><rect x="53.0502%" y="197" width="0.0103%" height="15" fill="rgb(241,52,2)" fg:x="20601" fg:w="4"/><text x="53.3002%" y="207.50"></text></g><g><title>futex_unqueue (7 samples, 0.02%)</title><rect x="53.1095%" y="181" width="0.0180%" height="15" fill="rgb(248,140,14)" fg:x="20624" fg:w="7"/><text x="53.3595%" y="191.50"></text></g><g><title>enqueue_hrtimer (5 samples, 0.01%)</title><rect x="53.1352%" y="117" width="0.0129%" height="15" fill="rgb(253,22,42)" fg:x="20634" fg:w="5"/><text x="53.3852%" y="127.50"></text></g><g><title>hrtimer_sleeper_start_expires (6 samples, 0.02%)</title><rect x="53.1352%" y="165" width="0.0155%" height="15" fill="rgb(234,61,47)" fg:x="20634" fg:w="6"/><text x="53.3852%" y="175.50"></text></g><g><title>hrtimer_start_range_ns (6 samples, 0.02%)</title><rect x="53.1352%" y="149" width="0.0155%" height="15" fill="rgb(208,226,15)" fg:x="20634" fg:w="6"/><text x="53.3852%" y="159.50"></text></g><g><title>__hrtimer_start_range_ns (6 samples, 0.02%)</title><rect x="53.1352%" y="133" width="0.0155%" height="15" fill="rgb(217,221,4)" fg:x="20634" fg:w="6"/><text x="53.3852%" y="143.50"></text></g><g><title>update_curr (5 samples, 0.01%)</title><rect x="53.1944%" y="85" width="0.0129%" height="15" fill="rgb(212,174,34)" fg:x="20657" fg:w="5"/><text x="53.4444%" y="95.50"></text></g><g><title>dequeue_task (14 samples, 0.04%)</title><rect x="53.1841%" y="133" width="0.0361%" height="15" fill="rgb(253,83,4)" fg:x="20653" fg:w="14"/><text x="53.4341%" y="143.50"></text></g><g><title>dequeue_task_fair (14 samples, 0.04%)</title><rect x="53.1841%" y="117" width="0.0361%" height="15" fill="rgb(250,195,49)" fg:x="20653" fg:w="14"/><text x="53.4341%" y="127.50"></text></g><g><title>dequeue_entity (14 samples, 0.04%)</title><rect x="53.1841%" y="101" width="0.0361%" height="15" fill="rgb(241,192,25)" fg:x="20653" fg:w="14"/><text x="53.4341%" y="111.50"></text></g><g><title>update_load_avg (5 samples, 0.01%)</title><rect x="53.2073%" y="85" width="0.0129%" height="15" fill="rgb(208,124,10)" fg:x="20662" fg:w="5"/><text x="53.4573%" y="95.50"></text></g><g><title>__perf_event_task_sched_in (11 samples, 0.03%)</title><rect x="53.2202%" y="117" width="0.0283%" height="15" fill="rgb(222,33,0)" fg:x="20667" fg:w="11"/><text x="53.4702%" y="127.50"></text></g><g><title>perf_ctx_enable (11 samples, 0.03%)</title><rect x="53.2202%" y="101" width="0.0283%" height="15" fill="rgb(234,209,28)" fg:x="20667" fg:w="11"/><text x="53.4702%" y="111.50"></text></g><g><title>finish_task_switch.isra.0 (16 samples, 0.04%)</title><rect x="53.2202%" y="133" width="0.0412%" height="15" fill="rgb(224,11,23)" fg:x="20667" fg:w="16"/><text x="53.4702%" y="143.50"></text></g><g><title>raw_spin_rq_unlock (4 samples, 0.01%)</title><rect x="53.2511%" y="117" width="0.0103%" height="15" fill="rgb(232,99,1)" fg:x="20679" fg:w="4"/><text x="53.5011%" y="127.50"></text></g><g><title>pick_next_task (4 samples, 0.01%)</title><rect x="53.2614%" y="133" width="0.0103%" height="15" fill="rgb(237,95,45)" fg:x="20683" fg:w="4"/><text x="53.5114%" y="143.50"></text></g><g><title>prepare_task_switch (4 samples, 0.01%)</title><rect x="53.2717%" y="133" width="0.0103%" height="15" fill="rgb(208,109,11)" fg:x="20687" fg:w="4"/><text x="53.5217%" y="143.50"></text></g><g><title>psi_group_change (8 samples, 0.02%)</title><rect x="53.2923%" y="117" width="0.0206%" height="15" fill="rgb(216,190,48)" fg:x="20695" fg:w="8"/><text x="53.5423%" y="127.50"></text></g><g><title>psi_task_switch (13 samples, 0.03%)</title><rect x="53.2846%" y="133" width="0.0335%" height="15" fill="rgb(251,171,36)" fg:x="20692" fg:w="13"/><text x="53.5346%" y="143.50"></text></g><g><title>futex_wait_queue (78 samples, 0.20%)</title><rect x="53.1275%" y="181" width="0.2009%" height="15" fill="rgb(230,62,22)" fg:x="20631" fg:w="78"/><text x="53.3775%" y="191.50"></text></g><g><title>schedule (68 samples, 0.18%)</title><rect x="53.1532%" y="165" width="0.1751%" height="15" fill="rgb(225,114,35)" fg:x="20641" fg:w="68"/><text x="53.4032%" y="175.50"></text></g><g><title>__schedule (66 samples, 0.17%)</title><rect x="53.1584%" y="149" width="0.1700%" height="15" fill="rgb(215,118,42)" fg:x="20643" fg:w="66"/><text x="53.4084%" y="159.50"></text></g><g><title>__get_user_nocheck_4 (4 samples, 0.01%)</title><rect x="53.3309%" y="165" width="0.0103%" height="15" fill="rgb(243,119,21)" fg:x="20710" fg:w="4"/><text x="53.5809%" y="175.50"></text></g><g><title>futex_q_lock (10 samples, 0.03%)</title><rect x="53.3464%" y="165" width="0.0258%" height="15" fill="rgb(252,177,53)" fg:x="20716" fg:w="10"/><text x="53.5964%" y="175.50"></text></g><g><title>futex_wait_setup (18 samples, 0.05%)</title><rect x="53.3284%" y="181" width="0.0464%" height="15" fill="rgb(237,209,29)" fg:x="20709" fg:w="18"/><text x="53.5784%" y="191.50"></text></g><g><title>hrtimer_cancel (7 samples, 0.02%)</title><rect x="53.3747%" y="181" width="0.0180%" height="15" fill="rgb(212,65,23)" fg:x="20727" fg:w="7"/><text x="53.6247%" y="191.50"></text></g><g><title>hrtimer_try_to_cancel (6 samples, 0.02%)</title><rect x="53.3773%" y="165" width="0.0155%" height="15" fill="rgb(230,222,46)" fg:x="20728" fg:w="6"/><text x="53.6273%" y="175.50"></text></g><g><title>futex_wait (117 samples, 0.30%)</title><rect x="53.0940%" y="197" width="0.3013%" height="15" fill="rgb(215,135,32)" fg:x="20618" fg:w="117"/><text x="53.3440%" y="207.50"></text></g><g><title>do_futex (120 samples, 0.31%)</title><rect x="53.0889%" y="213" width="0.3090%" height="15" fill="rgb(246,101,22)" fg:x="20616" fg:w="120"/><text x="53.3389%" y="223.50"></text></g><g><title>__x64_sys_futex (130 samples, 0.33%)</title><rect x="53.0734%" y="229" width="0.3348%" height="15" fill="rgb(206,107,13)" fg:x="20610" fg:w="130"/><text x="53.3234%" y="239.50"></text></g><g><title>get_timespec64 (4 samples, 0.01%)</title><rect x="53.3979%" y="213" width="0.0103%" height="15" fill="rgb(250,100,44)" fg:x="20736" fg:w="4"/><text x="53.6479%" y="223.50"></text></g><g><title>_copy_from_user (4 samples, 0.01%)</title><rect x="53.3979%" y="197" width="0.0103%" height="15" fill="rgb(231,147,38)" fg:x="20736" fg:w="4"/><text x="53.6479%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (8 samples, 0.02%)</title><rect x="53.4108%" y="213" width="0.0206%" height="15" fill="rgb(229,8,40)" fg:x="20741" fg:w="8"/><text x="53.6608%" y="223.50"></text></g><g><title>exit_to_user_mode_loop (8 samples, 0.02%)</title><rect x="53.4108%" y="197" width="0.0206%" height="15" fill="rgb(221,135,30)" fg:x="20741" fg:w="8"/><text x="53.6608%" y="207.50"></text></g><g><title>__rseq_handle_notify_resume (5 samples, 0.01%)</title><rect x="53.4185%" y="181" width="0.0129%" height="15" fill="rgb(249,193,18)" fg:x="20744" fg:w="5"/><text x="53.6685%" y="191.50"></text></g><g><title>std::sys_common::thread_parking::futex::Parker::park_timeout (157 samples, 0.40%)</title><rect x="53.0296%" y="309" width="0.4043%" height="15" fill="rgb(209,133,39)" fg:x="20593" fg:w="157"/><text x="53.2796%" y="319.50"></text></g><g><title>std::sys::unix::futex::futex_wait (152 samples, 0.39%)</title><rect x="53.0425%" y="293" width="0.3914%" height="15" fill="rgb(232,100,14)" fg:x="20598" fg:w="152"/><text x="53.2925%" y="303.50"></text></g><g><title>syscall (145 samples, 0.37%)</title><rect x="53.0605%" y="277" width="0.3734%" height="15" fill="rgb(224,185,1)" fg:x="20605" fg:w="145"/><text x="53.3105%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (140 samples, 0.36%)</title><rect x="53.0734%" y="261" width="0.3605%" height="15" fill="rgb(223,139,8)" fg:x="20610" fg:w="140"/><text x="53.3234%" y="271.50"></text></g><g><title>do_syscall_64 (140 samples, 0.36%)</title><rect x="53.0734%" y="245" width="0.3605%" height="15" fill="rgb(232,213,38)" fg:x="20610" fg:w="140"/><text x="53.3234%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (9 samples, 0.02%)</title><rect x="53.4108%" y="229" width="0.0232%" height="15" fill="rgb(207,94,22)" fg:x="20741" fg:w="9"/><text x="53.6608%" y="239.50"></text></g><g><title>std::thread::park_timeout (159 samples, 0.41%)</title><rect x="53.0296%" y="325" width="0.4094%" height="15" fill="rgb(219,183,54)" fg:x="20593" fg:w="159"/><text x="53.2796%" y="335.50"></text></g><g><title>std::sync::mpmc::context::Context::wait_until (168 samples, 0.43%)</title><rect x="53.0090%" y="341" width="0.4326%" height="15" fill="rgb(216,185,54)" fg:x="20585" fg:w="168"/><text x="53.2590%" y="351.50"></text></g><g><title>core::sync::atomic::AtomicBool::store (6 samples, 0.02%)</title><rect x="53.4468%" y="325" width="0.0155%" height="15" fill="rgb(254,217,39)" fg:x="20755" fg:w="6"/><text x="53.6968%" y="335.50"></text></g><g><title>core::sync::atomic::atomic_store (6 samples, 0.02%)</title><rect x="53.4468%" y="309" width="0.0155%" height="15" fill="rgb(240,178,23)" fg:x="20755" fg:w="6"/><text x="53.6968%" y="319.50"></text></g><g><title>std::sync::mpmc::context::Context::with (187 samples, 0.48%)</title><rect x="53.0013%" y="421" width="0.4815%" height="15" fill="rgb(218,11,47)" fg:x="20582" fg:w="187"/><text x="53.2513%" y="431.50"></text></g><g><title>std::thread::local::LocalKey&lt;T&gt;::try_with (187 samples, 0.48%)</title><rect x="53.0013%" y="405" width="0.4815%" height="15" fill="rgb(218,51,51)" fg:x="20582" fg:w="187"/><text x="53.2513%" y="415.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (187 samples, 0.48%)</title><rect x="53.0013%" y="389" width="0.4815%" height="15" fill="rgb(238,126,27)" fg:x="20582" fg:w="187"/><text x="53.2513%" y="399.50"></text></g><g><title>std::sync::mpmc::context::Context::with::_{{closure}} (187 samples, 0.48%)</title><rect x="53.0013%" y="373" width="0.4815%" height="15" fill="rgb(249,202,22)" fg:x="20582" fg:w="187"/><text x="53.2513%" y="383.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv::_{{closure}} (185 samples, 0.48%)</title><rect x="53.0065%" y="357" width="0.4764%" height="15" fill="rgb(254,195,49)" fg:x="20584" fg:w="185"/><text x="53.2565%" y="367.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::register (15 samples, 0.04%)</title><rect x="53.4442%" y="341" width="0.0386%" height="15" fill="rgb(208,123,14)" fg:x="20754" fg:w="15"/><text x="53.6942%" y="351.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (6 samples, 0.02%)</title><rect x="53.4674%" y="325" width="0.0155%" height="15" fill="rgb(224,200,8)" fg:x="20763" fg:w="6"/><text x="53.7174%" y="335.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (6 samples, 0.02%)</title><rect x="53.4674%" y="309" width="0.0155%" height="15" fill="rgb(217,61,36)" fg:x="20763" fg:w="6"/><text x="53.7174%" y="319.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (6 samples, 0.02%)</title><rect x="53.4674%" y="293" width="0.0155%" height="15" fill="rgb(206,35,45)" fg:x="20763" fg:w="6"/><text x="53.7174%" y="303.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (6 samples, 0.02%)</title><rect x="53.4674%" y="277" width="0.0155%" height="15" fill="rgb(217,65,33)" fg:x="20763" fg:w="6"/><text x="53.7174%" y="287.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (4 samples, 0.01%)</title><rect x="53.4829%" y="421" width="0.0103%" height="15" fill="rgb(222,158,48)" fg:x="20769" fg:w="4"/><text x="53.7329%" y="431.50"></text></g><g><title>clock_gettime (4 samples, 0.01%)</title><rect x="53.4829%" y="405" width="0.0103%" height="15" fill="rgb(254,2,54)" fg:x="20769" fg:w="4"/><text x="53.7329%" y="415.50"></text></g><g><title>[[vdso]] (4 samples, 0.01%)</title><rect x="53.4829%" y="389" width="0.0103%" height="15" fill="rgb(250,143,38)" fg:x="20769" fg:w="4"/><text x="53.7329%" y="399.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_deadline (418 samples, 1.08%)</title><rect x="52.4193%" y="453" width="1.0764%" height="15" fill="rgb(248,25,0)" fg:x="20356" fg:w="418"/><text x="52.6693%" y="463.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv (416 samples, 1.07%)</title><rect x="52.4245%" y="437" width="1.0713%" height="15" fill="rgb(206,152,27)" fg:x="20358" fg:w="416"/><text x="52.6745%" y="447.50"></text></g><g><title>[[vdso]] (164 samples, 0.42%)</title><rect x="53.5138%" y="421" width="0.4223%" height="15" fill="rgb(240,77,30)" fg:x="20781" fg:w="164"/><text x="53.7638%" y="431.50"></text></g><g><title>[[vdso]] (114 samples, 0.29%)</title><rect x="53.6425%" y="405" width="0.2936%" height="15" fill="rgb(231,5,3)" fg:x="20831" fg:w="114"/><text x="53.8925%" y="415.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (175 samples, 0.45%)</title><rect x="53.5009%" y="453" width="0.4506%" height="15" fill="rgb(207,226,32)" fg:x="20776" fg:w="175"/><text x="53.7509%" y="463.50"></text></g><g><title>clock_gettime (173 samples, 0.45%)</title><rect x="53.5060%" y="437" width="0.4455%" height="15" fill="rgb(222,207,47)" fg:x="20778" fg:w="173"/><text x="53.7560%" y="447.50"></text></g><g><title>__vdso_clock_gettime (6 samples, 0.02%)</title><rect x="53.9361%" y="421" width="0.0155%" height="15" fill="rgb(229,115,45)" fg:x="20945" fg:w="6"/><text x="54.1861%" y="431.50"></text></g><g><title>std::sync::mpsc::Receiver&lt;T&gt;::recv_timeout (634 samples, 1.63%)</title><rect x="52.3704%" y="485" width="1.6326%" height="15" fill="rgb(224,191,6)" fg:x="20337" fg:w="634"/><text x="52.6204%" y="495.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (628 samples, 1.62%)</title><rect x="52.3859%" y="469" width="1.6172%" height="15" fill="rgb(230,227,24)" fg:x="20343" fg:w="628"/><text x="52.6359%" y="479.50"></text></g><g><title>std::time::SystemTime::checked_add (17 samples, 0.04%)</title><rect x="53.9593%" y="453" width="0.0438%" height="15" fill="rgb(228,80,19)" fg:x="20954" fg:w="17"/><text x="54.2093%" y="463.50"></text></g><g><title>std::sys::unix::time::SystemTime::checked_add_duration (16 samples, 0.04%)</title><rect x="53.9618%" y="437" width="0.0412%" height="15" fill="rgb(247,229,0)" fg:x="20955" fg:w="16"/><text x="54.2118%" y="447.50"></text></g><g><title>std::sys::unix::time::Timespec::checked_add_duration (16 samples, 0.04%)</title><rect x="53.9618%" y="421" width="0.0412%" height="15" fill="rgb(237,194,15)" fg:x="20955" fg:w="16"/><text x="54.2118%" y="431.50"></text></g><g><title>core::option::Option&lt;T&gt;::and_then (8 samples, 0.02%)</title><rect x="53.9824%" y="405" width="0.0206%" height="15" fill="rgb(219,203,20)" fg:x="20963" fg:w="8"/><text x="54.2324%" y="415.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="54.0957%" y="341" width="0.0129%" height="15" fill="rgb(234,128,8)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="54.0957%" y="325" width="0.0129%" height="15" fill="rgb(248,202,8)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="335.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="54.0957%" y="309" width="0.0129%" height="15" fill="rgb(206,104,37)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="54.0957%" y="293" width="0.0129%" height="15" fill="rgb(223,8,27)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="54.0957%" y="277" width="0.0129%" height="15" fill="rgb(216,217,28)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="54.0957%" y="261" width="0.0129%" height="15" fill="rgb(249,199,1)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="54.0957%" y="245" width="0.0129%" height="15" fill="rgb(240,85,17)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="54.0957%" y="229" width="0.0129%" height="15" fill="rgb(206,108,45)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="239.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="54.0957%" y="213" width="0.0129%" height="15" fill="rgb(245,210,41)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="54.0957%" y="197" width="0.0129%" height="15" fill="rgb(206,13,37)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="207.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="54.0957%" y="181" width="0.0129%" height="15" fill="rgb(250,61,18)" fg:x="21007" fg:w="5"/><text x="54.3457%" y="191.50"></text></g><g><title>core::cmp::impls::&lt;impl core::cmp::PartialOrd&lt;&amp;B&gt; for &amp;A&gt;::ge (21 samples, 0.05%)</title><rect x="54.0571%" y="389" width="0.0541%" height="15" fill="rgb(235,172,48)" fg:x="20992" fg:w="21"/><text x="54.3071%" y="399.50"></text></g><g><title>core::cmp::PartialOrd::ge (21 samples, 0.05%)</title><rect x="54.0571%" y="373" width="0.0541%" height="15" fill="rgb(249,201,17)" fg:x="20992" fg:w="21"/><text x="54.3071%" y="383.50"></text></g><g><title>&lt;std::sys::unix::time::Timespec as core::cmp::PartialOrd&gt;::partial_cmp (15 samples, 0.04%)</title><rect x="54.0726%" y="357" width="0.0386%" height="15" fill="rgb(219,208,6)" fg:x="20998" fg:w="15"/><text x="54.3226%" y="367.50"></text></g><g><title>std::time::Instant::duration_since (45 samples, 0.12%)</title><rect x="54.0082%" y="453" width="0.1159%" height="15" fill="rgb(248,31,23)" fg:x="20973" fg:w="45"/><text x="54.2582%" y="463.50"></text></g><g><title>std::time::Instant::checked_duration_since (45 samples, 0.12%)</title><rect x="54.0082%" y="437" width="0.1159%" height="15" fill="rgb(245,15,42)" fg:x="20973" fg:w="45"/><text x="54.2582%" y="447.50"></text></g><g><title>std::sys::unix::time::inner::Instant::checked_sub_instant (45 samples, 0.12%)</title><rect x="54.0082%" y="421" width="0.1159%" height="15" fill="rgb(222,217,39)" fg:x="20973" fg:w="45"/><text x="54.2582%" y="431.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (45 samples, 0.12%)</title><rect x="54.0082%" y="405" width="0.1159%" height="15" fill="rgb(210,219,27)" fg:x="20973" fg:w="45"/><text x="54.2582%" y="415.50"></text></g><g><title>core::time::Duration::new (5 samples, 0.01%)</title><rect x="54.1112%" y="389" width="0.0129%" height="15" fill="rgb(252,166,36)" fg:x="21013" fg:w="5"/><text x="54.3612%" y="399.50"></text></g><g><title>&lt;std::time::Instant as core::ops::arith::Sub&gt;::sub (48 samples, 0.12%)</title><rect x="54.0082%" y="469" width="0.1236%" height="15" fill="rgb(245,132,34)" fg:x="20973" fg:w="48"/><text x="54.2582%" y="479.50"></text></g><g><title>[[vdso]] (111 samples, 0.29%)</title><rect x="54.2297%" y="389" width="0.2858%" height="15" fill="rgb(236,54,3)" fg:x="21059" fg:w="111"/><text x="54.4797%" y="399.50"></text></g><g><title>[[vdso]] (145 samples, 0.37%)</title><rect x="54.1550%" y="405" width="0.3734%" height="15" fill="rgb(241,173,43)" fg:x="21030" fg:w="145"/><text x="54.4050%" y="415.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="54.5155%" y="389" width="0.0129%" height="15" fill="rgb(215,190,9)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="399.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="54.5155%" y="373" width="0.0129%" height="15" fill="rgb(242,101,16)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="383.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="54.5155%" y="357" width="0.0129%" height="15" fill="rgb(223,190,21)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="367.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="54.5155%" y="341" width="0.0129%" height="15" fill="rgb(215,228,25)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="351.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="54.5155%" y="325" width="0.0129%" height="15" fill="rgb(225,36,22)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="335.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="54.5155%" y="309" width="0.0129%" height="15" fill="rgb(251,106,46)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="319.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="54.5155%" y="293" width="0.0129%" height="15" fill="rgb(208,90,1)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="303.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="54.5155%" y="277" width="0.0129%" height="15" fill="rgb(243,10,4)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="287.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="54.5155%" y="261" width="0.0129%" height="15" fill="rgb(212,137,27)" fg:x="21170" fg:w="5"/><text x="54.7655%" y="271.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="54.5181%" y="245" width="0.0103%" height="15" fill="rgb(231,220,49)" fg:x="21171" fg:w="4"/><text x="54.7681%" y="255.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="54.5181%" y="229" width="0.0103%" height="15" fill="rgb(237,96,20)" fg:x="21171" fg:w="4"/><text x="54.7681%" y="239.50"></text></g><g><title>std::time::Instant::elapsed (208 samples, 0.54%)</title><rect x="54.0030%" y="485" width="0.5356%" height="15" fill="rgb(239,229,30)" fg:x="20971" fg:w="208"/><text x="54.2530%" y="495.50"></text></g><g><title>std::time::Instant::now (158 samples, 0.41%)</title><rect x="54.1318%" y="469" width="0.4069%" height="15" fill="rgb(219,65,33)" fg:x="21021" fg:w="158"/><text x="54.3818%" y="479.50"></text></g><g><title>std::sys::unix::time::inner::Instant::now (158 samples, 0.41%)</title><rect x="54.1318%" y="453" width="0.4069%" height="15" fill="rgb(243,134,7)" fg:x="21021" fg:w="158"/><text x="54.3818%" y="463.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (155 samples, 0.40%)</title><rect x="54.1395%" y="437" width="0.3991%" height="15" fill="rgb(216,177,54)" fg:x="21024" fg:w="155"/><text x="54.3895%" y="447.50"></text></g><g><title>clock_gettime (151 samples, 0.39%)</title><rect x="54.1498%" y="421" width="0.3888%" height="15" fill="rgb(211,160,20)" fg:x="21028" fg:w="151"/><text x="54.3998%" y="431.50"></text></g><g><title>__vdso_clock_gettime (4 samples, 0.01%)</title><rect x="54.5284%" y="405" width="0.0103%" height="15" fill="rgb(239,85,39)" fg:x="21175" fg:w="4"/><text x="54.7784%" y="415.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (317 samples, 0.82%)</title><rect x="54.7138%" y="469" width="0.8163%" height="15" fill="rgb(232,125,22)" fg:x="21247" fg:w="317"/><text x="54.9638%" y="479.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (317 samples, 0.82%)</title><rect x="54.7138%" y="453" width="0.8163%" height="15" fill="rgb(244,57,34)" fg:x="21247" fg:w="317"/><text x="54.9638%" y="463.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (317 samples, 0.82%)</title><rect x="54.7138%" y="437" width="0.8163%" height="15" fill="rgb(214,203,32)" fg:x="21247" fg:w="317"/><text x="54.9638%" y="447.50"></text></g><g><title>&lt;core::result::Result&lt;T,E&gt; as core::ops::try_trait::Try&gt;::branch (6 samples, 0.02%)</title><rect x="55.5301%" y="469" width="0.0155%" height="15" fill="rgb(207,58,43)" fg:x="21564" fg:w="6"/><text x="55.7801%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (76 samples, 0.20%)</title><rect x="55.5533%" y="453" width="0.1957%" height="15" fill="rgb(215,193,15)" fg:x="21573" fg:w="76"/><text x="55.8033%" y="463.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (76 samples, 0.20%)</title><rect x="55.5533%" y="437" width="0.1957%" height="15" fill="rgb(232,15,44)" fg:x="21573" fg:w="76"/><text x="55.8033%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (75 samples, 0.19%)</title><rect x="55.5558%" y="421" width="0.1931%" height="15" fill="rgb(212,3,48)" fg:x="21574" fg:w="75"/><text x="55.8058%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (71 samples, 0.18%)</title><rect x="55.5661%" y="405" width="0.1828%" height="15" fill="rgb(218,128,7)" fg:x="21578" fg:w="71"/><text x="55.8161%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_swap (71 samples, 0.18%)</title><rect x="55.5661%" y="389" width="0.1828%" height="15" fill="rgb(226,216,39)" fg:x="21578" fg:w="71"/><text x="55.8161%" y="399.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (6 samples, 0.02%)</title><rect x="55.7490%" y="437" width="0.0155%" height="15" fill="rgb(243,47,51)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="447.50"></text></g><g><title>std::sync::poison::Flag::guard (6 samples, 0.02%)</title><rect x="55.7490%" y="421" width="0.0155%" height="15" fill="rgb(241,183,40)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="431.50"></text></g><g><title>std::thread::panicking (6 samples, 0.02%)</title><rect x="55.7490%" y="405" width="0.0155%" height="15" fill="rgb(231,217,32)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="415.50"></text></g><g><title>std::panicking::panicking (6 samples, 0.02%)</title><rect x="55.7490%" y="389" width="0.0155%" height="15" fill="rgb(229,61,38)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="399.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (6 samples, 0.02%)</title><rect x="55.7490%" y="373" width="0.0155%" height="15" fill="rgb(225,210,5)" fg:x="21649" fg:w="6"/><text x="55.9990%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (73 samples, 0.19%)</title><rect x="55.7490%" y="453" width="0.1880%" height="15" fill="rgb(231,79,45)" fg:x="21649" fg:w="73"/><text x="55.9990%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (67 samples, 0.17%)</title><rect x="55.7644%" y="437" width="0.1725%" height="15" fill="rgb(224,100,7)" fg:x="21655" fg:w="67"/><text x="56.0144%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (66 samples, 0.17%)</title><rect x="55.7670%" y="421" width="0.1700%" height="15" fill="rgb(241,198,18)" fg:x="21656" fg:w="66"/><text x="56.0170%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (66 samples, 0.17%)</title><rect x="55.7670%" y="405" width="0.1700%" height="15" fill="rgb(252,97,53)" fg:x="21656" fg:w="66"/><text x="56.0170%" y="415.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLDec as zssp::crypto::aes::Aes256Dec&gt;::decrypt_in_place (355 samples, 0.91%)</title><rect x="55.5533%" y="469" width="0.9142%" height="15" fill="rgb(220,88,7)" fg:x="21573" fg:w="355"/><text x="55.8033%" y="479.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (206 samples, 0.53%)</title><rect x="55.9370%" y="453" width="0.5305%" height="15" fill="rgb(213,176,14)" fg:x="21722" fg:w="206"/><text x="56.1870%" y="463.50"></text></g><g><title>EVP_DecryptUpdate (202 samples, 0.52%)</title><rect x="55.9473%" y="437" width="0.5202%" height="15" fill="rgb(246,73,7)" fg:x="21726" fg:w="202"/><text x="56.1973%" y="447.50"></text></g><g><title>[libcrypto.so.3] (165 samples, 0.42%)</title><rect x="56.0425%" y="421" width="0.4249%" height="15" fill="rgb(245,64,36)" fg:x="21763" fg:w="165"/><text x="56.2925%" y="431.50"></text></g><g><title>[libcrypto.so.3] (125 samples, 0.32%)</title><rect x="56.1455%" y="405" width="0.3219%" height="15" fill="rgb(245,80,10)" fg:x="21803" fg:w="125"/><text x="56.3955%" y="415.50"></text></g><g><title>[libcrypto.so.3] (116 samples, 0.30%)</title><rect x="56.1687%" y="389" width="0.2987%" height="15" fill="rgb(232,107,50)" fg:x="21812" fg:w="116"/><text x="56.4187%" y="399.50"></text></g><g><title>__rust_probestack (6 samples, 0.02%)</title><rect x="56.4674%" y="469" width="0.0155%" height="15" fill="rgb(253,3,0)" fg:x="21928" fg:w="6"/><text x="56.7174%" y="479.50"></text></g><g><title>core::cmp::Ord::max (5 samples, 0.01%)</title><rect x="56.4829%" y="469" width="0.0129%" height="15" fill="rgb(212,99,53)" fg:x="21934" fg:w="5"/><text x="56.7329%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (5 samples, 0.01%)</title><rect x="56.4829%" y="453" width="0.0129%" height="15" fill="rgb(249,111,54)" fg:x="21934" fg:w="5"/><text x="56.7329%" y="463.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade::_{{closure}} (6 samples, 0.02%)</title><rect x="56.5189%" y="405" width="0.0155%" height="15" fill="rgb(249,55,30)" fg:x="21948" fg:w="6"/><text x="56.7689%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (73 samples, 0.19%)</title><rect x="56.5344%" y="405" width="0.1880%" height="15" fill="rgb(237,47,42)" fg:x="21954" fg:w="73"/><text x="56.7844%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (73 samples, 0.19%)</title><rect x="56.5344%" y="389" width="0.1880%" height="15" fill="rgb(211,20,18)" fg:x="21954" fg:w="73"/><text x="56.7844%" y="399.50"></text></g><g><title>alloc::sync::Weak&lt;T&gt;::upgrade (92 samples, 0.24%)</title><rect x="56.5009%" y="437" width="0.2369%" height="15" fill="rgb(231,203,46)" fg:x="21941" fg:w="92"/><text x="56.7509%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_update (88 samples, 0.23%)</title><rect x="56.5112%" y="421" width="0.2266%" height="15" fill="rgb(237,142,3)" fg:x="21945" fg:w="88"/><text x="56.7612%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (6 samples, 0.02%)</title><rect x="56.7224%" y="405" width="0.0155%" height="15" fill="rgb(241,107,1)" fg:x="22027" fg:w="6"/><text x="56.9724%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="56.7224%" y="389" width="0.0155%" height="15" fill="rgb(229,83,13)" fg:x="22027" fg:w="6"/><text x="56.9724%" y="399.50"></text></g><g><title>core::option::Option&lt;T&gt;::map (99 samples, 0.25%)</title><rect x="56.5009%" y="469" width="0.2549%" height="15" fill="rgb(241,91,40)" fg:x="21941" fg:w="99"/><text x="56.7509%" y="479.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive::_{{closure}} (99 samples, 0.25%)</title><rect x="56.5009%" y="453" width="0.2549%" height="15" fill="rgb(225,3,45)" fg:x="21941" fg:w="99"/><text x="56.7509%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (7 samples, 0.02%)</title><rect x="56.7378%" y="437" width="0.0180%" height="15" fill="rgb(244,223,14)" fg:x="22033" fg:w="7"/><text x="56.9878%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::sync::Arc&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt; (45 samples, 0.12%)</title><rect x="56.7559%" y="469" width="0.1159%" height="15" fill="rgb(224,124,37)" fg:x="22040" fg:w="45"/><text x="57.0059%" y="479.50"></text></g><g><title>&lt;alloc::sync::Arc&lt;T&gt; as core::ops::drop::Drop&gt;::drop (45 samples, 0.12%)</title><rect x="56.7559%" y="453" width="0.1159%" height="15" fill="rgb(251,171,30)" fg:x="22040" fg:w="45"/><text x="57.0059%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicUsize::fetch_sub (43 samples, 0.11%)</title><rect x="56.7610%" y="437" width="0.1107%" height="15" fill="rgb(236,46,54)" fg:x="22042" fg:w="43"/><text x="57.0110%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_sub (43 samples, 0.11%)</title><rect x="56.7610%" y="421" width="0.1107%" height="15" fill="rgb(245,213,5)" fg:x="22042" fg:w="43"/><text x="57.0110%" y="431.50"></text></g><g><title>__rdl_dealloc (4 samples, 0.01%)</title><rect x="56.8949%" y="293" width="0.0103%" height="15" fill="rgb(230,144,27)" fg:x="22094" fg:w="4"/><text x="57.1449%" y="303.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::dealloc (4 samples, 0.01%)</title><rect x="56.8949%" y="277" width="0.0103%" height="15" fill="rgb(220,86,6)" fg:x="22094" fg:w="4"/><text x="57.1449%" y="287.50"></text></g><g><title>__rust_dealloc (9 samples, 0.02%)</title><rect x="56.9052%" y="293" width="0.0232%" height="15" fill="rgb(240,20,13)" fg:x="22098" fg:w="9"/><text x="57.1552%" y="303.50"></text></g><g><title>[libc.so.6] (76 samples, 0.20%)</title><rect x="58.2494%" y="261" width="0.1957%" height="15" fill="rgb(217,89,34)" fg:x="22620" fg:w="76"/><text x="58.4994%" y="271.50"></text></g><g><title>__entry_text_start (13 samples, 0.03%)</title><rect x="58.5687%" y="245" width="0.0335%" height="15" fill="rgb(229,13,5)" fg:x="22744" fg:w="13"/><text x="58.8187%" y="255.50"></text></g><g><title>futex_unqueue (17 samples, 0.04%)</title><rect x="58.6640%" y="165" width="0.0438%" height="15" fill="rgb(244,67,35)" fg:x="22781" fg:w="17"/><text x="58.9140%" y="175.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="58.7876%" y="117" width="0.0103%" height="15" fill="rgb(221,40,2)" fg:x="22829" fg:w="4"/><text x="59.0376%" y="127.50"></text></g><g><title>cpuacct_charge (10 samples, 0.03%)</title><rect x="58.8520%" y="53" width="0.0258%" height="15" fill="rgb(237,157,21)" fg:x="22854" fg:w="10"/><text x="59.1020%" y="63.50"></text></g><g><title>update_curr (18 samples, 0.05%)</title><rect x="58.8340%" y="69" width="0.0464%" height="15" fill="rgb(222,94,11)" fg:x="22847" fg:w="18"/><text x="59.0840%" y="79.50"></text></g><g><title>dequeue_entity (32 samples, 0.08%)</title><rect x="58.8108%" y="85" width="0.0824%" height="15" fill="rgb(249,113,6)" fg:x="22838" fg:w="32"/><text x="59.0608%" y="95.50"></text></g><g><title>update_load_avg (5 samples, 0.01%)</title><rect x="58.8803%" y="69" width="0.0129%" height="15" fill="rgb(238,137,36)" fg:x="22865" fg:w="5"/><text x="59.1303%" y="79.50"></text></g><g><title>dequeue_task (42 samples, 0.11%)</title><rect x="58.7979%" y="117" width="0.1082%" height="15" fill="rgb(210,102,26)" fg:x="22833" fg:w="42"/><text x="59.0479%" y="127.50"></text></g><g><title>dequeue_task_fair (42 samples, 0.11%)</title><rect x="58.7979%" y="101" width="0.1082%" height="15" fill="rgb(218,30,30)" fg:x="22833" fg:w="42"/><text x="59.0479%" y="111.50"></text></g><g><title>__perf_event_task_sched_in (9 samples, 0.02%)</title><rect x="58.9267%" y="101" width="0.0232%" height="15" fill="rgb(214,67,26)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="111.50"></text></g><g><title>perf_ctx_enable (9 samples, 0.02%)</title><rect x="58.9267%" y="85" width="0.0232%" height="15" fill="rgb(251,9,53)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="95.50"></text></g><g><title>x86_pmu_enable (9 samples, 0.02%)</title><rect x="58.9267%" y="69" width="0.0232%" height="15" fill="rgb(228,204,25)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="79.50"></text></g><g><title>intel_pmu_enable_all (9 samples, 0.02%)</title><rect x="58.9267%" y="53" width="0.0232%" height="15" fill="rgb(207,153,8)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="63.50"></text></g><g><title>native_write_msr (9 samples, 0.02%)</title><rect x="58.9267%" y="37" width="0.0232%" height="15" fill="rgb(242,9,16)" fg:x="22883" fg:w="9"/><text x="59.1767%" y="47.50"></text></g><g><title>finish_task_switch.isra.0 (29 samples, 0.07%)</title><rect x="58.9112%" y="117" width="0.0747%" height="15" fill="rgb(217,211,10)" fg:x="22877" fg:w="29"/><text x="59.1612%" y="127.50"></text></g><g><title>raw_spin_rq_unlock (12 samples, 0.03%)</title><rect x="58.9550%" y="101" width="0.0309%" height="15" fill="rgb(219,228,52)" fg:x="22894" fg:w="12"/><text x="59.2050%" y="111.50"></text></g><g><title>pick_next_task_fair (4 samples, 0.01%)</title><rect x="58.9859%" y="101" width="0.0103%" height="15" fill="rgb(231,92,29)" fg:x="22906" fg:w="4"/><text x="59.2359%" y="111.50"></text></g><g><title>pick_next_task (10 samples, 0.03%)</title><rect x="58.9859%" y="117" width="0.0258%" height="15" fill="rgb(232,8,23)" fg:x="22906" fg:w="10"/><text x="59.2359%" y="127.50"></text></g><g><title>put_prev_task_fair (6 samples, 0.02%)</title><rect x="58.9962%" y="101" width="0.0155%" height="15" fill="rgb(216,211,34)" fg:x="22910" fg:w="6"/><text x="59.2462%" y="111.50"></text></g><g><title>prepare_task_switch (15 samples, 0.04%)</title><rect x="59.0117%" y="117" width="0.0386%" height="15" fill="rgb(236,151,0)" fg:x="22916" fg:w="15"/><text x="59.2617%" y="127.50"></text></g><g><title>__perf_event_task_sched_out (6 samples, 0.02%)</title><rect x="59.0348%" y="101" width="0.0155%" height="15" fill="rgb(209,168,3)" fg:x="22925" fg:w="6"/><text x="59.2848%" y="111.50"></text></g><g><title>psi_group_change (38 samples, 0.10%)</title><rect x="59.0760%" y="101" width="0.0979%" height="15" fill="rgb(208,129,28)" fg:x="22941" fg:w="38"/><text x="59.3260%" y="111.50"></text></g><g><title>psi_task_switch (52 samples, 0.13%)</title><rect x="59.0554%" y="117" width="0.1339%" height="15" fill="rgb(229,78,22)" fg:x="22933" fg:w="52"/><text x="59.3054%" y="127.50"></text></g><g><title>__schedule (179 samples, 0.46%)</title><rect x="58.7516%" y="133" width="0.4609%" height="15" fill="rgb(228,187,13)" fg:x="22815" fg:w="179"/><text x="59.0016%" y="143.50"></text></g><g><title>update_rq_clock (5 samples, 0.01%)</title><rect x="59.1996%" y="117" width="0.0129%" height="15" fill="rgb(240,119,24)" fg:x="22989" fg:w="5"/><text x="59.4496%" y="127.50"></text></g><g><title>sched_clock_cpu (5 samples, 0.01%)</title><rect x="59.1996%" y="101" width="0.0129%" height="15" fill="rgb(209,194,42)" fg:x="22989" fg:w="5"/><text x="59.4496%" y="111.50"></text></g><g><title>sched_clock (4 samples, 0.01%)</title><rect x="59.2022%" y="85" width="0.0103%" height="15" fill="rgb(247,200,46)" fg:x="22990" fg:w="4"/><text x="59.4522%" y="95.50"></text></g><g><title>native_sched_clock (4 samples, 0.01%)</title><rect x="59.2022%" y="69" width="0.0103%" height="15" fill="rgb(218,76,16)" fg:x="22990" fg:w="4"/><text x="59.4522%" y="79.50"></text></g><g><title>futex_wait_queue (199 samples, 0.51%)</title><rect x="58.7078%" y="165" width="0.5125%" height="15" fill="rgb(225,21,48)" fg:x="22798" fg:w="199"/><text x="58.9578%" y="175.50"></text></g><g><title>schedule (187 samples, 0.48%)</title><rect x="58.7387%" y="149" width="0.4815%" height="15" fill="rgb(239,223,50)" fg:x="22810" fg:w="187"/><text x="58.9887%" y="159.50"></text></g><g><title>__get_user_nocheck_4 (26 samples, 0.07%)</title><rect x="59.2280%" y="149" width="0.0670%" height="15" fill="rgb(244,45,21)" fg:x="23000" fg:w="26"/><text x="59.4780%" y="159.50"></text></g><g><title>_raw_spin_lock (4 samples, 0.01%)</title><rect x="59.2949%" y="149" width="0.0103%" height="15" fill="rgb(232,33,43)" fg:x="23026" fg:w="4"/><text x="59.5449%" y="159.50"></text></g><g><title>futex_hash (5 samples, 0.01%)</title><rect x="59.3078%" y="149" width="0.0129%" height="15" fill="rgb(209,8,3)" fg:x="23031" fg:w="5"/><text x="59.5578%" y="159.50"></text></g><g><title>futex_q_lock (5 samples, 0.01%)</title><rect x="59.3207%" y="149" width="0.0129%" height="15" fill="rgb(214,25,53)" fg:x="23036" fg:w="5"/><text x="59.5707%" y="159.50"></text></g><g><title>futex_q_unlock (5 samples, 0.01%)</title><rect x="59.3336%" y="149" width="0.0129%" height="15" fill="rgb(254,186,54)" fg:x="23041" fg:w="5"/><text x="59.5836%" y="159.50"></text></g><g><title>futex_wait (278 samples, 0.72%)</title><rect x="58.6383%" y="181" width="0.7159%" height="15" fill="rgb(208,174,49)" fg:x="22771" fg:w="278"/><text x="58.8883%" y="191.50"></text></g><g><title>futex_wait_setup (52 samples, 0.13%)</title><rect x="59.2203%" y="165" width="0.1339%" height="15" fill="rgb(233,191,51)" fg:x="22997" fg:w="52"/><text x="59.4703%" y="175.50"></text></g><g><title>do_futex (282 samples, 0.73%)</title><rect x="58.6305%" y="197" width="0.7262%" height="15" fill="rgb(222,134,10)" fg:x="22768" fg:w="282"/><text x="58.8805%" y="207.50"></text></g><g><title>__x64_sys_futex (292 samples, 0.75%)</title><rect x="58.6099%" y="213" width="0.7519%" height="15" fill="rgb(230,226,20)" fg:x="22760" fg:w="292"/><text x="58.8599%" y="223.50"></text></g><g><title>__get_user_8 (5 samples, 0.01%)</title><rect x="59.4263%" y="133" width="0.0129%" height="15" fill="rgb(251,111,25)" fg:x="23077" fg:w="5"/><text x="59.6763%" y="143.50"></text></g><g><title>rseq_ip_fixup (11 samples, 0.03%)</title><rect x="59.4134%" y="149" width="0.0283%" height="15" fill="rgb(224,40,46)" fg:x="23072" fg:w="11"/><text x="59.6634%" y="159.50"></text></g><g><title>exit_to_user_mode_loop (24 samples, 0.06%)</title><rect x="59.3851%" y="181" width="0.0618%" height="15" fill="rgb(236,108,47)" fg:x="23061" fg:w="24"/><text x="59.6351%" y="191.50"></text></g><g><title>__rseq_handle_notify_resume (15 samples, 0.04%)</title><rect x="59.4082%" y="165" width="0.0386%" height="15" fill="rgb(234,93,0)" fg:x="23070" fg:w="15"/><text x="59.6582%" y="175.50"></text></g><g><title>exit_to_user_mode_prepare (31 samples, 0.08%)</title><rect x="59.3748%" y="197" width="0.0798%" height="15" fill="rgb(224,213,32)" fg:x="23057" fg:w="31"/><text x="59.6248%" y="207.50"></text></g><g><title>do_syscall_64 (331 samples, 0.85%)</title><rect x="58.6074%" y="229" width="0.8524%" height="15" fill="rgb(251,11,48)" fg:x="22759" fg:w="331"/><text x="58.8574%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (36 samples, 0.09%)</title><rect x="59.3670%" y="213" width="0.0927%" height="15" fill="rgb(236,173,5)" fg:x="23054" fg:w="36"/><text x="59.6170%" y="223.50"></text></g><g><title>__lll_lock_wait_private (397 samples, 1.02%)</title><rect x="58.4451%" y="261" width="1.0223%" height="15" fill="rgb(230,95,12)" fg:x="22696" fg:w="397"/><text x="58.6951%" y="271.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (335 samples, 0.86%)</title><rect x="58.6048%" y="245" width="0.8627%" height="15" fill="rgb(232,209,1)" fg:x="22758" fg:w="335"/><text x="58.8548%" y="255.50"></text></g><g><title>[libc.so.6] (911 samples, 2.35%)</title><rect x="57.1241%" y="277" width="2.3459%" height="15" fill="rgb(232,6,1)" fg:x="22183" fg:w="911"/><text x="57.3741%" y="287.50">[..</text></g><g><title>__entry_text_start (15 samples, 0.04%)</title><rect x="59.4881%" y="261" width="0.0386%" height="15" fill="rgb(210,224,50)" fg:x="23101" fg:w="15"/><text x="59.7381%" y="271.50"></text></g><g><title>do_syscall_64 (4 samples, 0.01%)</title><rect x="59.5267%" y="261" width="0.0103%" height="15" fill="rgb(228,127,35)" fg:x="23116" fg:w="4"/><text x="59.7767%" y="271.50"></text></g><g><title>_raw_spin_lock (5 samples, 0.01%)</title><rect x="59.5679%" y="197" width="0.0129%" height="15" fill="rgb(245,102,45)" fg:x="23132" fg:w="5"/><text x="59.8179%" y="207.50"></text></g><g><title>futex_hash (8 samples, 0.02%)</title><rect x="59.5833%" y="197" width="0.0206%" height="15" fill="rgb(214,1,49)" fg:x="23138" fg:w="8"/><text x="59.8333%" y="207.50"></text></g><g><title>_raw_spin_lock (25 samples, 0.06%)</title><rect x="59.7147%" y="181" width="0.0644%" height="15" fill="rgb(226,163,40)" fg:x="23189" fg:w="25"/><text x="59.9647%" y="191.50"></text></g><g><title>native_queued_spin_lock_slowpath (25 samples, 0.06%)</title><rect x="59.7147%" y="165" width="0.0644%" height="15" fill="rgb(239,212,28)" fg:x="23189" fg:w="25"/><text x="59.9647%" y="175.50"></text></g><g><title>_raw_spin_unlock (4 samples, 0.01%)</title><rect x="59.7791%" y="181" width="0.0103%" height="15" fill="rgb(220,20,13)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="191.50"></text></g><g><title>preempt_schedule_thunk (4 samples, 0.01%)</title><rect x="59.7791%" y="165" width="0.0103%" height="15" fill="rgb(210,164,35)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="175.50"></text></g><g><title>preempt_schedule (4 samples, 0.01%)</title><rect x="59.7791%" y="149" width="0.0103%" height="15" fill="rgb(248,109,41)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="159.50"></text></g><g><title>__schedule (4 samples, 0.01%)</title><rect x="59.7791%" y="133" width="0.0103%" height="15" fill="rgb(238,23,50)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (4 samples, 0.01%)</title><rect x="59.7791%" y="117" width="0.0103%" height="15" fill="rgb(211,48,49)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (4 samples, 0.01%)</title><rect x="59.7791%" y="101" width="0.0103%" height="15" fill="rgb(223,36,21)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="111.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="59.7791%" y="85" width="0.0103%" height="15" fill="rgb(207,123,46)" fg:x="23214" fg:w="4"/><text x="60.0291%" y="95.50"></text></g><g><title>futex_wake (77 samples, 0.20%)</title><rect x="59.6039%" y="197" width="0.1983%" height="15" fill="rgb(240,218,32)" fg:x="23146" fg:w="77"/><text x="59.8539%" y="207.50"></text></g><g><title>do_futex (97 samples, 0.25%)</title><rect x="59.5627%" y="213" width="0.2498%" height="15" fill="rgb(252,5,43)" fg:x="23130" fg:w="97"/><text x="59.8127%" y="223.50"></text></g><g><title>__x64_sys_futex (101 samples, 0.26%)</title><rect x="59.5550%" y="229" width="0.2601%" height="15" fill="rgb(252,84,19)" fg:x="23127" fg:w="101"/><text x="59.8050%" y="239.50"></text></g><g><title>do_syscall_64 (113 samples, 0.29%)</title><rect x="59.5499%" y="245" width="0.2910%" height="15" fill="rgb(243,152,39)" fg:x="23125" fg:w="113"/><text x="59.7999%" y="255.50"></text></g><g><title>syscall_exit_to_user_mode (6 samples, 0.02%)</title><rect x="59.8254%" y="229" width="0.0155%" height="15" fill="rgb(234,160,15)" fg:x="23232" fg:w="6"/><text x="60.0754%" y="239.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="59.8280%" y="213" width="0.0129%" height="15" fill="rgb(237,34,20)" fg:x="23233" fg:w="5"/><text x="60.0780%" y="223.50"></text></g><g><title>alloc::alloc::dealloc (1,146 samples, 2.95%)</title><rect x="56.8949%" y="309" width="2.9511%" height="15" fill="rgb(229,97,13)" fg:x="22094" fg:w="1146"/><text x="57.1449%" y="319.50">all..</text></g><g><title>cfree (1,133 samples, 2.92%)</title><rect x="56.9284%" y="293" width="2.9176%" height="15" fill="rgb(234,71,50)" fg:x="22107" fg:w="1133"/><text x="57.1784%" y="303.50">cf..</text></g><g><title>__lll_lock_wake_private (146 samples, 0.38%)</title><rect x="59.4700%" y="277" width="0.3760%" height="15" fill="rgb(253,155,4)" fg:x="23094" fg:w="146"/><text x="59.7200%" y="287.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (120 samples, 0.31%)</title><rect x="59.5370%" y="261" width="0.3090%" height="15" fill="rgb(222,185,37)" fg:x="23120" fg:w="120"/><text x="59.7870%" y="271.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (1,151 samples, 2.96%)</title><rect x="56.8949%" y="325" width="2.9640%" height="15" fill="rgb(251,177,13)" fg:x="22094" fg:w="1151"/><text x="57.1449%" y="335.50">&lt;al..</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (5 samples, 0.01%)</title><rect x="59.8460%" y="309" width="0.0129%" height="15" fill="rgb(250,179,40)" fg:x="23240" fg:w="5"/><text x="60.0960%" y="319.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (1,169 samples, 3.01%)</title><rect x="56.8717%" y="469" width="3.0103%" height="15" fill="rgb(242,44,2)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="479.50">cor..</text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (1,169 samples, 3.01%)</title><rect x="56.8717%" y="453" width="3.0103%" height="15" fill="rgb(216,177,13)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="463.50">&lt;ar..</text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (1,169 samples, 3.01%)</title><rect x="56.8717%" y="437" width="3.0103%" height="15" fill="rgb(216,106,43)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="447.50">arr..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (1,169 samples, 3.01%)</title><rect x="56.8717%" y="421" width="3.0103%" height="15" fill="rgb(216,183,2)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="431.50">arr..</text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (1,169 samples, 3.01%)</title><rect x="56.8717%" y="405" width="3.0103%" height="15" fill="rgb(249,75,3)" fg:x="22085" fg:w="1169"/><text x="57.1217%" y="415.50">arr..</text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (1,162 samples, 2.99%)</title><rect x="56.8898%" y="389" width="2.9923%" height="15" fill="rgb(219,67,39)" fg:x="22092" fg:w="1162"/><text x="57.1398%" y="399.50">cor..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (1,161 samples, 2.99%)</title><rect x="56.8923%" y="373" width="2.9897%" height="15" fill="rgb(253,228,2)" fg:x="22093" fg:w="1161"/><text x="57.1423%" y="383.50">cor..</text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (1,161 samples, 2.99%)</title><rect x="56.8923%" y="357" width="2.9897%" height="15" fill="rgb(235,138,27)" fg:x="22093" fg:w="1161"/><text x="57.1423%" y="367.50">cor..</text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (1,161 samples, 2.99%)</title><rect x="56.8923%" y="341" width="2.9897%" height="15" fill="rgb(236,97,51)" fg:x="22093" fg:w="1161"/><text x="57.1423%" y="351.50">&lt;al..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::current_memory (9 samples, 0.02%)</title><rect x="59.8589%" y="325" width="0.0232%" height="15" fill="rgb(240,80,30)" fg:x="23245" fg:w="9"/><text x="60.1089%" y="335.50"></text></g><g><title>std::sync::poison::Flag::done (4 samples, 0.01%)</title><rect x="59.8821%" y="437" width="0.0103%" height="15" fill="rgb(230,178,19)" fg:x="23254" fg:w="4"/><text x="60.1321%" y="447.50"></text></g><g><title>std::thread::panicking (4 samples, 0.01%)</title><rect x="59.8821%" y="421" width="0.0103%" height="15" fill="rgb(210,190,27)" fg:x="23254" fg:w="4"/><text x="60.1321%" y="431.50"></text></g><g><title>std::panicking::panicking (4 samples, 0.01%)</title><rect x="59.8821%" y="405" width="0.0103%" height="15" fill="rgb(222,107,31)" fg:x="23254" fg:w="4"/><text x="60.1321%" y="415.50"></text></g><g><title>std::panicking::panic_count::count_is_zero (4 samples, 0.01%)</title><rect x="59.8821%" y="389" width="0.0103%" height="15" fill="rgb(216,127,34)" fg:x="23254" fg:w="4"/><text x="60.1321%" y="399.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (83 samples, 0.21%)</title><rect x="59.8821%" y="453" width="0.2137%" height="15" fill="rgb(234,116,52)" fg:x="23254" fg:w="83"/><text x="60.1321%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (79 samples, 0.20%)</title><rect x="59.8924%" y="437" width="0.2034%" height="15" fill="rgb(222,124,15)" fg:x="23258" fg:w="79"/><text x="60.1424%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (76 samples, 0.20%)</title><rect x="59.9001%" y="421" width="0.1957%" height="15" fill="rgb(231,179,28)" fg:x="23261" fg:w="76"/><text x="60.1501%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_swap (76 samples, 0.20%)</title><rect x="59.9001%" y="405" width="0.1957%" height="15" fill="rgb(226,93,45)" fg:x="23261" fg:w="76"/><text x="60.1501%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (87 samples, 0.22%)</title><rect x="59.8821%" y="469" width="0.2240%" height="15" fill="rgb(215,8,51)" fg:x="23254" fg:w="87"/><text x="60.1321%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (4 samples, 0.01%)</title><rect x="60.0958%" y="453" width="0.0103%" height="15" fill="rgb(223,106,5)" fg:x="23337" fg:w="4"/><text x="60.3458%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;std::collections::hash::map::HashMap&lt;core::num::nonzero::NonZeroU32,alloc::sync::Weak&lt;zssp::zeta::Session&lt;benchmark::TestApplication&gt;&gt;&gt;&gt;&gt; (88 samples, 0.23%)</title><rect x="60.1061%" y="469" width="0.2266%" height="15" fill="rgb(250,191,5)" fg:x="23341" fg:w="88"/><text x="60.3561%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (88 samples, 0.23%)</title><rect x="60.1061%" y="453" width="0.2266%" height="15" fill="rgb(242,132,44)" fg:x="23341" fg:w="88"/><text x="60.3561%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (88 samples, 0.23%)</title><rect x="60.1061%" y="437" width="0.2266%" height="15" fill="rgb(251,152,29)" fg:x="23341" fg:w="88"/><text x="60.3561%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (80 samples, 0.21%)</title><rect x="60.1267%" y="421" width="0.2060%" height="15" fill="rgb(218,179,5)" fg:x="23349" fg:w="80"/><text x="60.3767%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (80 samples, 0.21%)</title><rect x="60.1267%" y="405" width="0.2060%" height="15" fill="rgb(227,67,19)" fg:x="23349" fg:w="80"/><text x="60.3767%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (59 samples, 0.15%)</title><rect x="60.3327%" y="469" width="0.1519%" height="15" fill="rgb(233,119,31)" fg:x="23429" fg:w="59"/><text x="60.5827%" y="479.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (59 samples, 0.15%)</title><rect x="60.3327%" y="453" width="0.1519%" height="15" fill="rgb(241,120,22)" fg:x="23429" fg:w="59"/><text x="60.5827%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (59 samples, 0.15%)</title><rect x="60.3327%" y="437" width="0.1519%" height="15" fill="rgb(224,102,30)" fg:x="23429" fg:w="59"/><text x="60.5827%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (54 samples, 0.14%)</title><rect x="60.3456%" y="421" width="0.1391%" height="15" fill="rgb(210,164,37)" fg:x="23434" fg:w="54"/><text x="60.5956%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (54 samples, 0.14%)</title><rect x="60.3456%" y="405" width="0.1391%" height="15" fill="rgb(226,191,16)" fg:x="23434" fg:w="54"/><text x="60.5956%" y="415.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (6 samples, 0.02%)</title><rect x="60.4872%" y="469" width="0.0155%" height="15" fill="rgb(214,40,45)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="479.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (6 samples, 0.02%)</title><rect x="60.4872%" y="453" width="0.0155%" height="15" fill="rgb(244,29,26)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="463.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (6 samples, 0.02%)</title><rect x="60.4872%" y="437" width="0.0155%" height="15" fill="rgb(216,16,5)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="447.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::add (6 samples, 0.02%)</title><rect x="60.4872%" y="421" width="0.0155%" height="15" fill="rgb(249,76,35)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="431.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::offset (6 samples, 0.02%)</title><rect x="60.4872%" y="405" width="0.0155%" height="15" fill="rgb(207,11,44)" fg:x="23489" fg:w="6"/><text x="60.7372%" y="415.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (9 samples, 0.02%)</title><rect x="60.5593%" y="325" width="0.0232%" height="15" fill="rgb(228,190,49)" fg:x="23517" fg:w="9"/><text x="60.8093%" y="335.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::c_rounds (22 samples, 0.06%)</title><rect x="60.5413%" y="341" width="0.0567%" height="15" fill="rgb(214,173,12)" fg:x="23510" fg:w="22"/><text x="60.7913%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (6 samples, 0.02%)</title><rect x="60.5825%" y="325" width="0.0155%" height="15" fill="rgb(218,26,35)" fg:x="23526" fg:w="6"/><text x="60.8325%" y="335.50"></text></g><g><title>core::num::&lt;impl u64&gt;::rotate_left (15 samples, 0.04%)</title><rect x="60.6211%" y="325" width="0.0386%" height="15" fill="rgb(220,200,19)" fg:x="23541" fg:w="15"/><text x="60.8711%" y="335.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::finish (78 samples, 0.20%)</title><rect x="60.5104%" y="389" width="0.2009%" height="15" fill="rgb(239,95,49)" fg:x="23498" fg:w="78"/><text x="60.7604%" y="399.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::finish (78 samples, 0.20%)</title><rect x="60.5104%" y="373" width="0.2009%" height="15" fill="rgb(235,85,53)" fg:x="23498" fg:w="78"/><text x="60.7604%" y="383.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::finish (78 samples, 0.20%)</title><rect x="60.5104%" y="357" width="0.2009%" height="15" fill="rgb(233,133,31)" fg:x="23498" fg:w="78"/><text x="60.7604%" y="367.50"></text></g><g><title>&lt;core::hash::sip::Sip13Rounds as core::hash::sip::Sip&gt;::d_rounds (44 samples, 0.11%)</title><rect x="60.5979%" y="341" width="0.1133%" height="15" fill="rgb(218,25,20)" fg:x="23532" fg:w="44"/><text x="60.8479%" y="351.50"></text></g><g><title>core::num::&lt;impl u64&gt;::wrapping_add (20 samples, 0.05%)</title><rect x="60.6597%" y="325" width="0.0515%" height="15" fill="rgb(252,210,38)" fg:x="23556" fg:w="20"/><text x="60.9097%" y="335.50"></text></g><g><title>hashbrown::map::make_hash (98 samples, 0.25%)</title><rect x="60.5027%" y="421" width="0.2524%" height="15" fill="rgb(242,134,21)" fg:x="23495" fg:w="98"/><text x="60.7527%" y="431.50"></text></g><g><title>core::hash::BuildHasher::hash_one (98 samples, 0.25%)</title><rect x="60.5027%" y="405" width="0.2524%" height="15" fill="rgb(213,28,48)" fg:x="23495" fg:w="98"/><text x="60.7527%" y="415.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (15 samples, 0.04%)</title><rect x="60.7164%" y="389" width="0.0386%" height="15" fill="rgb(250,196,2)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="399.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::hash::Hash&gt;::hash (15 samples, 0.04%)</title><rect x="60.7164%" y="373" width="0.0386%" height="15" fill="rgb(227,5,17)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="383.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for u32&gt;::hash (15 samples, 0.04%)</title><rect x="60.7164%" y="357" width="0.0386%" height="15" fill="rgb(221,226,24)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="367.50"></text></g><g><title>core::hash::Hasher::write_u32 (15 samples, 0.04%)</title><rect x="60.7164%" y="341" width="0.0386%" height="15" fill="rgb(211,5,48)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="351.50"></text></g><g><title>&lt;std::collections::hash::map::DefaultHasher as core::hash::Hasher&gt;::write (15 samples, 0.04%)</title><rect x="60.7164%" y="325" width="0.0386%" height="15" fill="rgb(219,150,6)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="335.50"></text></g><g><title>&lt;core::hash::sip::SipHasher13 as core::hash::Hasher&gt;::write (15 samples, 0.04%)</title><rect x="60.7164%" y="309" width="0.0386%" height="15" fill="rgb(251,46,16)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="319.50"></text></g><g><title>&lt;core::hash::sip::Hasher&lt;S&gt; as core::hash::Hasher&gt;::write (15 samples, 0.04%)</title><rect x="60.7164%" y="293" width="0.0386%" height="15" fill="rgb(220,204,40)" fg:x="23578" fg:w="15"/><text x="60.9664%" y="303.50"></text></g><g><title>core::hash::sip::u8to64_le (10 samples, 0.03%)</title><rect x="60.7293%" y="277" width="0.0258%" height="15" fill="rgb(211,85,2)" fg:x="23583" fg:w="10"/><text x="60.9793%" y="287.50"></text></g><g><title>&lt;hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator&gt;::next (6 samples, 0.02%)</title><rect x="60.7808%" y="373" width="0.0155%" height="15" fill="rgb(229,17,7)" fg:x="23603" fg:w="6"/><text x="61.0308%" y="383.50"></text></g><g><title>hashbrown::map::equivalent_key::_{{closure}} (10 samples, 0.03%)</title><rect x="60.7962%" y="357" width="0.0258%" height="15" fill="rgb(239,72,28)" fg:x="23609" fg:w="10"/><text x="61.0462%" y="367.50"></text></g><g><title>&lt;core::num::nonzero::NonZeroU32 as core::cmp::PartialEq&gt;::eq (10 samples, 0.03%)</title><rect x="60.7962%" y="341" width="0.0258%" height="15" fill="rgb(230,47,54)" fg:x="23609" fg:w="10"/><text x="61.0462%" y="351.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find::_{{closure}} (17 samples, 0.04%)</title><rect x="60.7962%" y="373" width="0.0438%" height="15" fill="rgb(214,50,8)" fg:x="23609" fg:w="17"/><text x="61.0462%" y="383.50"></text></g><g><title>hashbrown::raw::Bucket&lt;T&gt;::as_ref (7 samples, 0.02%)</title><rect x="60.8220%" y="357" width="0.0180%" height="15" fill="rgb(216,198,43)" fg:x="23619" fg:w="7"/><text x="61.0720%" y="367.50"></text></g><g><title>hashbrown::raw::Bucket&lt;T&gt;::as_ptr (7 samples, 0.02%)</title><rect x="60.8220%" y="341" width="0.0180%" height="15" fill="rgb(234,20,35)" fg:x="23619" fg:w="7"/><text x="61.0720%" y="351.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::sub (7 samples, 0.02%)</title><rect x="60.8220%" y="325" width="0.0180%" height="15" fill="rgb(254,45,19)" fg:x="23619" fg:w="7"/><text x="61.0720%" y="335.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::offset (7 samples, 0.02%)</title><rect x="60.8220%" y="309" width="0.0180%" height="15" fill="rgb(219,14,44)" fg:x="23619" fg:w="7"/><text x="61.0720%" y="319.50"></text></g><g><title>hashbrown::raw::h2 (14 samples, 0.04%)</title><rect x="60.8400%" y="373" width="0.0361%" height="15" fill="rgb(217,220,26)" fg:x="23626" fg:w="14"/><text x="61.0900%" y="383.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (149 samples, 0.38%)</title><rect x="60.5027%" y="437" width="0.3837%" height="15" fill="rgb(213,158,28)" fg:x="23495" fg:w="149"/><text x="60.7527%" y="447.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::get (51 samples, 0.13%)</title><rect x="60.7550%" y="421" width="0.1313%" height="15" fill="rgb(252,51,52)" fg:x="23593" fg:w="51"/><text x="61.0050%" y="431.50"></text></g><g><title>hashbrown::raw::RawTable&lt;T,A&gt;::find (51 samples, 0.13%)</title><rect x="60.7550%" y="405" width="0.1313%" height="15" fill="rgb(246,89,16)" fg:x="23593" fg:w="51"/><text x="61.0050%" y="415.50"></text></g><g><title>hashbrown::raw::RawTableInner&lt;A&gt;::find_inner (51 samples, 0.13%)</title><rect x="60.7550%" y="389" width="0.1313%" height="15" fill="rgb(216,158,49)" fg:x="23593" fg:w="51"/><text x="61.0050%" y="399.50"></text></g><g><title>hashbrown::raw::sse2::Group::match_byte (4 samples, 0.01%)</title><rect x="60.8761%" y="373" width="0.0103%" height="15" fill="rgb(236,107,19)" fg:x="23640" fg:w="4"/><text x="61.1261%" y="383.50"></text></g><g><title>core::core_arch::x86::sse2::_mm_movemask_epi8 (4 samples, 0.01%)</title><rect x="60.8761%" y="357" width="0.0103%" height="15" fill="rgb(228,185,30)" fg:x="23640" fg:w="4"/><text x="61.1261%" y="367.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (153 samples, 0.39%)</title><rect x="60.5027%" y="469" width="0.3940%" height="15" fill="rgb(246,134,8)" fg:x="23495" fg:w="153"/><text x="60.7527%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (153 samples, 0.39%)</title><rect x="60.5027%" y="453" width="0.3940%" height="15" fill="rgb(214,143,50)" fg:x="23495" fg:w="153"/><text x="60.7527%" y="463.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (4 samples, 0.01%)</title><rect x="60.8864%" y="437" width="0.0103%" height="15" fill="rgb(228,75,8)" fg:x="23644" fg:w="4"/><text x="61.1364%" y="447.50"></text></g><g><title>std::sync::mutex::MutexGuard&lt;T&gt;::new (5 samples, 0.01%)</title><rect x="60.8992%" y="453" width="0.0129%" height="15" fill="rgb(207,175,4)" fg:x="23649" fg:w="5"/><text x="61.1492%" y="463.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (50 samples, 0.13%)</title><rect x="60.8967%" y="469" width="0.1288%" height="15" fill="rgb(205,108,24)" fg:x="23648" fg:w="50"/><text x="61.1467%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (44 samples, 0.11%)</title><rect x="60.9121%" y="453" width="0.1133%" height="15" fill="rgb(244,120,49)" fg:x="23654" fg:w="44"/><text x="61.1621%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (42 samples, 0.11%)</title><rect x="60.9173%" y="437" width="0.1082%" height="15" fill="rgb(223,47,38)" fg:x="23656" fg:w="42"/><text x="61.1673%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (42 samples, 0.11%)</title><rect x="60.9173%" y="421" width="0.1082%" height="15" fill="rgb(229,179,11)" fg:x="23656" fg:w="42"/><text x="61.1673%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (135 samples, 0.35%)</title><rect x="61.0640%" y="437" width="0.3476%" height="15" fill="rgb(231,122,1)" fg:x="23713" fg:w="135"/><text x="61.3140%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (135 samples, 0.35%)</title><rect x="61.0640%" y="421" width="0.3476%" height="15" fill="rgb(245,119,9)" fg:x="23713" fg:w="135"/><text x="61.3140%" y="431.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (158 samples, 0.41%)</title><rect x="61.0254%" y="469" width="0.4069%" height="15" fill="rgb(241,163,25)" fg:x="23698" fg:w="158"/><text x="61.2754%" y="479.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (158 samples, 0.41%)</title><rect x="61.0254%" y="453" width="0.4069%" height="15" fill="rgb(217,214,3)" fg:x="23698" fg:w="158"/><text x="61.2754%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::is_read_lockable (8 samples, 0.02%)</title><rect x="61.4117%" y="437" width="0.0206%" height="15" fill="rgb(240,86,28)" fg:x="23848" fg:w="8"/><text x="61.6617%" y="447.50"></text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::check (10 samples, 0.03%)</title><rect x="61.4323%" y="469" width="0.0258%" height="15" fill="rgb(215,47,9)" fg:x="23856" fg:w="10"/><text x="61.6823%" y="479.50"></text></g><g><title>core::sync::atomic::AtomicU64::load (6 samples, 0.02%)</title><rect x="61.4426%" y="453" width="0.0155%" height="15" fill="rgb(252,25,45)" fg:x="23860" fg:w="6"/><text x="61.6926%" y="463.50"></text></g><g><title>core::sync::atomic::atomic_load (6 samples, 0.02%)</title><rect x="61.4426%" y="437" width="0.0155%" height="15" fill="rgb(251,164,9)" fg:x="23860" fg:w="6"/><text x="61.6926%" y="447.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::push (19 samples, 0.05%)</title><rect x="61.5121%" y="453" width="0.0489%" height="15" fill="rgb(233,194,0)" fg:x="23887" fg:w="19"/><text x="61.7621%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push (19 samples, 0.05%)</title><rect x="61.5121%" y="437" width="0.0489%" height="15" fill="rgb(249,111,24)" fg:x="23887" fg:w="19"/><text x="61.7621%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::try_push (19 samples, 0.05%)</title><rect x="61.5121%" y="421" width="0.0489%" height="15" fill="rgb(250,223,3)" fg:x="23887" fg:w="19"/><text x="61.7621%" y="431.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::push_unchecked (11 samples, 0.03%)</title><rect x="61.5327%" y="405" width="0.0283%" height="15" fill="rgb(236,178,37)" fg:x="23895" fg:w="11"/><text x="61.7827%" y="415.50"></text></g><g><title>core::ptr::write (11 samples, 0.03%)</title><rect x="61.5327%" y="389" width="0.0283%" height="15" fill="rgb(241,158,50)" fg:x="23895" fg:w="11"/><text x="61.7827%" y="399.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (59 samples, 0.15%)</title><rect x="61.4580%" y="469" width="0.1519%" height="15" fill="rgb(213,121,41)" fg:x="23866" fg:w="59"/><text x="61.7080%" y="479.50"></text></g><g><title>&lt;T as core::convert::TryInto&lt;U&gt;&gt;::try_into (39 samples, 0.10%)</title><rect x="61.6151%" y="453" width="0.1004%" height="15" fill="rgb(240,92,3)" fg:x="23927" fg:w="39"/><text x="61.8651%" y="463.50"></text></g><g><title>core::array::_&lt;impl core::convert::TryFrom&lt;&amp;[T]&gt; for [T: N]&gt;::try_from (39 samples, 0.10%)</title><rect x="61.6151%" y="437" width="0.1004%" height="15" fill="rgb(205,123,3)" fg:x="23927" fg:w="39"/><text x="61.8651%" y="447.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map (39 samples, 0.10%)</title><rect x="61.6151%" y="421" width="0.1004%" height="15" fill="rgb(205,97,47)" fg:x="23927" fg:w="39"/><text x="61.8651%" y="431.50"></text></g><g><title>zssp::zeta::from_nonce (44 samples, 0.11%)</title><rect x="61.6100%" y="469" width="0.1133%" height="15" fill="rgb(247,152,14)" fg:x="23925" fg:w="44"/><text x="61.8600%" y="479.50"></text></g><g><title>&lt;core::slice::iter::IterMut&lt;T&gt; as core::iter::traits::iterator::Iterator&gt;::next (4 samples, 0.01%)</title><rect x="61.7774%" y="453" width="0.0103%" height="15" fill="rgb(248,195,53)" fg:x="23990" fg:w="4"/><text x="62.0274%" y="463.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (60 samples, 0.15%)</title><rect x="61.7877%" y="453" width="0.1545%" height="15" fill="rgb(226,201,16)" fg:x="23994" fg:w="60"/><text x="62.0377%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (60 samples, 0.15%)</title><rect x="61.7877%" y="437" width="0.1545%" height="15" fill="rgb(205,98,0)" fg:x="23994" fg:w="60"/><text x="62.0377%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (60 samples, 0.15%)</title><rect x="61.7877%" y="421" width="0.1545%" height="15" fill="rgb(214,191,48)" fg:x="23994" fg:w="60"/><text x="62.0377%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_sub (60 samples, 0.15%)</title><rect x="61.7877%" y="405" width="0.1545%" height="15" fill="rgb(237,112,39)" fg:x="23994" fg:w="60"/><text x="62.0377%" y="415.50"></text></g><g><title>EVP_CIPHER_CTX_get_block_size (5 samples, 0.01%)</title><rect x="62.1713%" y="405" width="0.0129%" height="15" fill="rgb(247,203,27)" fg:x="24143" fg:w="5"/><text x="62.4213%" y="415.50"></text></g><g><title>CRYPTO_gcm128_decrypt (268 samples, 0.69%)</title><rect x="62.3722%" y="357" width="0.6901%" height="15" fill="rgb(235,124,28)" fg:x="24221" fg:w="268"/><text x="62.6222%" y="367.50"></text></g><g><title>[libcrypto.so.3] (104 samples, 0.27%)</title><rect x="62.7945%" y="341" width="0.2678%" height="15" fill="rgb(208,207,46)" fg:x="24385" fg:w="104"/><text x="63.0445%" y="351.50"></text></g><g><title>CRYPTO_gcm128_decrypt_ctr32 (512 samples, 1.32%)</title><rect x="63.0623%" y="357" width="1.3185%" height="15" fill="rgb(234,176,4)" fg:x="24489" fg:w="512"/><text x="63.3123%" y="367.50"></text></g><g><title>[libcrypto.so.3] (396 samples, 1.02%)</title><rect x="63.3611%" y="341" width="1.0198%" height="15" fill="rgb(230,133,28)" fg:x="24605" fg:w="396"/><text x="63.6111%" y="351.50"></text></g><g><title>[libcrypto.so.3] (25 samples, 0.06%)</title><rect x="64.3164%" y="325" width="0.0644%" height="15" fill="rgb(211,137,40)" fg:x="24976" fg:w="25"/><text x="64.5664%" y="335.50"></text></g><g><title>CRYPTO_gcm128_setiv (25 samples, 0.06%)</title><rect x="64.3808%" y="357" width="0.0644%" height="15" fill="rgb(254,35,13)" fg:x="25001" fg:w="25"/><text x="64.6308%" y="367.50"></text></g><g><title>[libcrypto.so.3] (22 samples, 0.06%)</title><rect x="64.3885%" y="341" width="0.0567%" height="15" fill="rgb(225,49,51)" fg:x="25004" fg:w="22"/><text x="64.6385%" y="351.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::decrypt_in_place (4,728 samples, 12.18%)</title><rect x="61.9422%" y="453" width="12.1752%" height="15" fill="rgb(251,10,15)" fg:x="24054" fg:w="4728"/><text x="62.1922%" y="463.50">&lt;zssp::crypto_impl..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (4,725 samples, 12.17%)</title><rect x="61.9499%" y="437" width="12.1675%" height="15" fill="rgb(228,207,15)" fg:x="24057" fg:w="4725"/><text x="62.1999%" y="447.50">zssp::crypto_impl:..</text></g><g><title>EVP_DecryptUpdate (4,725 samples, 12.17%)</title><rect x="61.9499%" y="421" width="12.1675%" height="15" fill="rgb(241,99,19)" fg:x="24057" fg:w="4725"/><text x="62.1999%" y="431.50">EVP_DecryptUpdate</text></g><g><title>[libcrypto.so.3] (4,634 samples, 11.93%)</title><rect x="62.1842%" y="405" width="11.9331%" height="15" fill="rgb(207,104,49)" fg:x="24148" fg:w="4634"/><text x="62.4342%" y="415.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,632 samples, 11.93%)</title><rect x="62.1894%" y="389" width="11.9280%" height="15" fill="rgb(234,99,18)" fg:x="24150" fg:w="4632"/><text x="62.4394%" y="399.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (4,611 samples, 11.87%)</title><rect x="62.2435%" y="373" width="11.8739%" height="15" fill="rgb(213,191,49)" fg:x="24171" fg:w="4611"/><text x="62.4935%" y="383.50">[libcrypto.so.3]</text></g><g><title>[libcrypto.so.3] (3,756 samples, 9.67%)</title><rect x="64.4452%" y="357" width="9.6722%" height="15" fill="rgb(210,226,19)" fg:x="25026" fg:w="3756"/><text x="64.6952%" y="367.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,594 samples, 9.26%)</title><rect x="64.8624%" y="341" width="9.2550%" height="15" fill="rgb(229,97,18)" fg:x="25188" fg:w="3594"/><text x="65.1124%" y="351.50">[libcrypto.so..</text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec&gt; (7 samples, 0.02%)</title><rect x="74.1174%" y="437" width="0.0180%" height="15" fill="rgb(211,167,15)" fg:x="28782" fg:w="7"/><text x="74.3674%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (7 samples, 0.02%)</title><rect x="74.1174%" y="421" width="0.0180%" height="15" fill="rgb(210,169,34)" fg:x="28782" fg:w="7"/><text x="74.3674%" y="431.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (7 samples, 0.02%)</title><rect x="74.1174%" y="405" width="0.0180%" height="15" fill="rgb(241,121,31)" fg:x="28782" fg:w="7"/><text x="74.3674%" y="415.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (6 samples, 0.02%)</title><rect x="74.1199%" y="389" width="0.0155%" height="15" fill="rgb(232,40,11)" fg:x="28783" fg:w="6"/><text x="74.3699%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (6 samples, 0.02%)</title><rect x="74.1199%" y="373" width="0.0155%" height="15" fill="rgb(205,86,26)" fg:x="28783" fg:w="6"/><text x="74.3699%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_swap (6 samples, 0.02%)</title><rect x="74.1199%" y="357" width="0.0155%" height="15" fill="rgb(231,126,28)" fg:x="28783" fg:w="6"/><text x="74.3699%" y="367.50"></text></g><g><title>[libc.so.6] (4 samples, 0.01%)</title><rect x="74.2075%" y="341" width="0.0103%" height="15" fill="rgb(219,221,18)" fg:x="28817" fg:w="4"/><text x="74.4575%" y="351.50"></text></g><g><title>CRYPTO_gcm128_finish (47 samples, 0.12%)</title><rect x="74.1689%" y="357" width="0.1210%" height="15" fill="rgb(211,40,0)" fg:x="28802" fg:w="47"/><text x="74.4189%" y="367.50"></text></g><g><title>[libcrypto.so.3] (28 samples, 0.07%)</title><rect x="74.2178%" y="341" width="0.0721%" height="15" fill="rgb(239,85,43)" fg:x="28821" fg:w="28"/><text x="74.4678%" y="351.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (63 samples, 0.16%)</title><rect x="74.1354%" y="437" width="0.1622%" height="15" fill="rgb(231,55,21)" fg:x="28789" fg:w="63"/><text x="74.3854%" y="447.50"></text></g><g><title>EVP_DecryptFinal_ex (63 samples, 0.16%)</title><rect x="74.1354%" y="421" width="0.1622%" height="15" fill="rgb(225,184,43)" fg:x="28789" fg:w="63"/><text x="74.3854%" y="431.50"></text></g><g><title>[libcrypto.so.3] (58 samples, 0.15%)</title><rect x="74.1483%" y="405" width="0.1494%" height="15" fill="rgb(251,158,41)" fg:x="28794" fg:w="58"/><text x="74.3983%" y="415.50"></text></g><g><title>[libcrypto.so.3] (56 samples, 0.14%)</title><rect x="74.1534%" y="389" width="0.1442%" height="15" fill="rgb(234,159,37)" fg:x="28796" fg:w="56"/><text x="74.4034%" y="399.50"></text></g><g><title>[libcrypto.so.3] (51 samples, 0.13%)</title><rect x="74.1663%" y="373" width="0.1313%" height="15" fill="rgb(216,204,22)" fg:x="28801" fg:w="51"/><text x="74.4163%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (27 samples, 0.07%)</title><rect x="74.4341%" y="389" width="0.0695%" height="15" fill="rgb(214,17,3)" fg:x="28905" fg:w="27"/><text x="74.6841%" y="399.50"></text></g><g><title>[libc.so.6] (12 samples, 0.03%)</title><rect x="74.4727%" y="373" width="0.0309%" height="15" fill="rgb(212,111,17)" fg:x="28920" fg:w="12"/><text x="74.7227%" y="383.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLDec as zssp::crypto::aes::AesGcmDecContext&gt;::finish (152 samples, 0.39%)</title><rect x="74.1174%" y="453" width="0.3914%" height="15" fill="rgb(221,157,24)" fg:x="28782" fg:w="152"/><text x="74.3674%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::set_tag (82 samples, 0.21%)</title><rect x="74.2976%" y="437" width="0.2112%" height="15" fill="rgb(252,16,13)" fg:x="28852" fg:w="82"/><text x="74.5476%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (82 samples, 0.21%)</title><rect x="74.2976%" y="421" width="0.2112%" height="15" fill="rgb(221,62,2)" fg:x="28852" fg:w="82"/><text x="74.5476%" y="431.50"></text></g><g><title>[libcrypto.so.3] (41 samples, 0.11%)</title><rect x="74.4032%" y="405" width="0.1056%" height="15" fill="rgb(247,87,22)" fg:x="28893" fg:w="41"/><text x="74.6532%" y="415.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (16 samples, 0.04%)</title><rect x="74.5088%" y="437" width="0.0412%" height="15" fill="rgb(215,73,9)" fg:x="28934" fg:w="16"/><text x="74.7588%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (16 samples, 0.04%)</title><rect x="74.5088%" y="421" width="0.0412%" height="15" fill="rgb(207,175,33)" fg:x="28934" fg:w="16"/><text x="74.7588%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (15 samples, 0.04%)</title><rect x="74.5114%" y="405" width="0.0386%" height="15" fill="rgb(243,129,54)" fg:x="28935" fg:w="15"/><text x="74.7614%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (15 samples, 0.04%)</title><rect x="74.5114%" y="389" width="0.0386%" height="15" fill="rgb(227,119,45)" fg:x="28935" fg:w="15"/><text x="74.7614%" y="399.50"></text></g><g><title>[libc.so.6] (22 samples, 0.06%)</title><rect x="74.7483%" y="341" width="0.0567%" height="15" fill="rgb(205,109,36)" fg:x="29027" fg:w="22"/><text x="74.9983%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (47 samples, 0.12%)</title><rect x="74.6865%" y="357" width="0.1210%" height="15" fill="rgb(205,6,39)" fg:x="29003" fg:w="47"/><text x="74.9365%" y="367.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (68 samples, 0.18%)</title><rect x="74.6350%" y="389" width="0.1751%" height="15" fill="rgb(221,32,16)" fg:x="28983" fg:w="68"/><text x="74.8850%" y="399.50"></text></g><g><title>[libcrypto.so.3] (52 samples, 0.13%)</title><rect x="74.6762%" y="373" width="0.1339%" height="15" fill="rgb(228,144,50)" fg:x="28999" fg:w="52"/><text x="74.9262%" y="383.50"></text></g><g><title>[libc.so.6] (27 samples, 0.07%)</title><rect x="74.9285%" y="341" width="0.0695%" height="15" fill="rgb(229,201,53)" fg:x="29097" fg:w="27"/><text x="75.1785%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (49 samples, 0.13%)</title><rect x="74.8899%" y="357" width="0.1262%" height="15" fill="rgb(249,153,27)" fg:x="29082" fg:w="49"/><text x="75.1399%" y="367.50"></text></g><g><title>strcmp@plt (7 samples, 0.02%)</title><rect x="74.9981%" y="341" width="0.0180%" height="15" fill="rgb(227,106,25)" fg:x="29124" fg:w="7"/><text x="75.2481%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (86 samples, 0.22%)</title><rect x="74.8101%" y="389" width="0.2215%" height="15" fill="rgb(230,65,29)" fg:x="29051" fg:w="86"/><text x="75.0601%" y="399.50"></text></g><g><title>[libcrypto.so.3] (66 samples, 0.17%)</title><rect x="74.8616%" y="373" width="0.1700%" height="15" fill="rgb(221,57,46)" fg:x="29071" fg:w="66"/><text x="75.1116%" y="383.50"></text></g><g><title>OSSL_PARAM_locate_const (6 samples, 0.02%)</title><rect x="75.0161%" y="357" width="0.0155%" height="15" fill="rgb(229,161,17)" fg:x="29131" fg:w="6"/><text x="75.2661%" y="367.50"></text></g><g><title>EVP_CIPHER_free (15 samples, 0.04%)</title><rect x="75.0315%" y="389" width="0.0386%" height="15" fill="rgb(222,213,11)" fg:x="29137" fg:w="15"/><text x="75.2815%" y="399.50"></text></g><g><title>EVP_CipherInit_ex (252 samples, 0.65%)</title><rect x="74.5526%" y="421" width="0.6489%" height="15" fill="rgb(235,35,13)" fg:x="28951" fg:w="252"/><text x="74.8026%" y="431.50"></text></g><g><title>[libcrypto.so.3] (252 samples, 0.65%)</title><rect x="74.5526%" y="405" width="0.6489%" height="15" fill="rgb(233,158,34)" fg:x="28951" fg:w="252"/><text x="74.8026%" y="415.50"></text></g><g><title>EVP_CIPHER_up_ref (51 samples, 0.13%)</title><rect x="75.0702%" y="389" width="0.1313%" height="15" fill="rgb(215,151,48)" fg:x="29152" fg:w="51"/><text x="75.3202%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_dec (270 samples, 0.70%)</title><rect x="74.5088%" y="453" width="0.6953%" height="15" fill="rgb(229,84,14)" fg:x="28934" fg:w="270"/><text x="74.7588%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (254 samples, 0.65%)</title><rect x="74.5500%" y="437" width="0.6541%" height="15" fill="rgb(229,68,14)" fg:x="28950" fg:w="254"/><text x="74.8000%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (7 samples, 0.02%)</title><rect x="75.2118%" y="453" width="0.0180%" height="15" fill="rgb(243,106,26)" fg:x="29207" fg:w="7"/><text x="75.4618%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (7 samples, 0.02%)</title><rect x="75.2118%" y="437" width="0.0180%" height="15" fill="rgb(206,45,38)" fg:x="29207" fg:w="7"/><text x="75.4618%" y="447.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (4 samples, 0.01%)</title><rect x="75.2195%" y="421" width="0.0103%" height="15" fill="rgb(226,6,15)" fg:x="29210" fg:w="4"/><text x="75.4695%" y="431.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::get_unchecked_mut (4 samples, 0.01%)</title><rect x="75.2195%" y="405" width="0.0103%" height="15" fill="rgb(232,22,54)" fg:x="29210" fg:w="4"/><text x="75.4695%" y="415.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::remaining_capacity (5 samples, 0.01%)</title><rect x="75.2298%" y="421" width="0.0129%" height="15" fill="rgb(229,222,32)" fg:x="29214" fg:w="5"/><text x="75.4798%" y="431.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::try_extend_from_slice (240 samples, 0.62%)</title><rect x="75.2427%" y="421" width="0.6180%" height="15" fill="rgb(228,62,29)" fg:x="29219" fg:w="240"/><text x="75.4927%" y="431.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (238 samples, 0.61%)</title><rect x="75.2479%" y="405" width="0.6129%" height="15" fill="rgb(251,103,34)" fg:x="29221" fg:w="238"/><text x="75.4979%" y="415.50"></text></g><g><title>[libc.so.6] (238 samples, 0.61%)</title><rect x="75.2479%" y="389" width="0.6129%" height="15" fill="rgb(233,12,30)" fg:x="29221" fg:w="238"/><text x="75.4979%" y="399.50"></text></g><g><title>std::io::impls::&lt;impl std::io::Write for &amp;mut W&gt;::write (247 samples, 0.64%)</title><rect x="75.2298%" y="453" width="0.6361%" height="15" fill="rgb(238,52,0)" fg:x="29214" fg:w="247"/><text x="75.4798%" y="463.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;u8,_&gt; as std::io::Write&gt;::write (247 samples, 0.64%)</title><rect x="75.2298%" y="437" width="0.6361%" height="15" fill="rgb(223,98,5)" fg:x="29214" fg:w="247"/><text x="75.4798%" y="447.50"></text></g><g><title>zssp::zeta::receive_payload_in_place (5,500 samples, 14.16%)</title><rect x="61.7233%" y="469" width="14.1632%" height="15" fill="rgb(228,75,37)" fg:x="23969" fg:w="5500"/><text x="61.9733%" y="479.50">zssp::zeta::receive_pa..</text></g><g><title>zssp::antireplay::Window&lt;_,_&gt;::update (8 samples, 0.02%)</title><rect x="75.8659%" y="453" width="0.0206%" height="15" fill="rgb(205,115,49)" fg:x="29461" fg:w="8"/><text x="76.1159%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_max (8 samples, 0.02%)</title><rect x="75.8659%" y="437" width="0.0206%" height="15" fill="rgb(250,154,43)" fg:x="29461" fg:w="8"/><text x="76.1159%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_umax (8 samples, 0.02%)</title><rect x="75.8659%" y="421" width="0.0206%" height="15" fill="rgb(226,43,29)" fg:x="29461" fg:w="8"/><text x="76.1159%" y="431.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (8,391 samples, 21.61%)</title><rect x="54.5387%" y="485" width="21.6079%" height="15" fill="rgb(249,228,39)" fg:x="21179" fg:w="8391"/><text x="54.7887%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::recei..</text></g><g><title>zssp::zssp::parse_fragment_header (101 samples, 0.26%)</title><rect x="75.8865%" y="469" width="0.2601%" height="15" fill="rgb(216,79,43)" fg:x="29469" fg:w="101"/><text x="76.1365%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (73 samples, 0.19%)</title><rect x="76.2213%" y="437" width="0.1880%" height="15" fill="rgb(228,95,12)" fg:x="29599" fg:w="73"/><text x="76.4713%" y="447.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (73 samples, 0.19%)</title><rect x="76.2213%" y="421" width="0.1880%" height="15" fill="rgb(249,221,15)" fg:x="29599" fg:w="73"/><text x="76.4713%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (70 samples, 0.18%)</title><rect x="76.2290%" y="405" width="0.1803%" height="15" fill="rgb(233,34,13)" fg:x="29602" fg:w="70"/><text x="76.4790%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (66 samples, 0.17%)</title><rect x="76.2393%" y="389" width="0.1700%" height="15" fill="rgb(214,103,39)" fg:x="29606" fg:w="66"/><text x="76.4893%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_swap (66 samples, 0.17%)</title><rect x="76.2393%" y="373" width="0.1700%" height="15" fill="rgb(251,126,39)" fg:x="29606" fg:w="66"/><text x="76.4893%" y="383.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (77 samples, 0.20%)</title><rect x="76.4092%" y="437" width="0.1983%" height="15" fill="rgb(214,216,36)" fg:x="29672" fg:w="77"/><text x="76.6592%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (76 samples, 0.20%)</title><rect x="76.4118%" y="421" width="0.1957%" height="15" fill="rgb(220,221,8)" fg:x="29673" fg:w="76"/><text x="76.6618%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (73 samples, 0.19%)</title><rect x="76.4195%" y="405" width="0.1880%" height="15" fill="rgb(240,216,3)" fg:x="29676" fg:w="73"/><text x="76.6695%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (73 samples, 0.19%)</title><rect x="76.4195%" y="389" width="0.1880%" height="15" fill="rgb(232,218,17)" fg:x="29676" fg:w="73"/><text x="76.6695%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::Aes256OpenSSLEnc as zssp::crypto::aes::Aes256Enc&gt;::encrypt_in_place (321 samples, 0.83%)</title><rect x="76.1981%" y="453" width="0.8266%" height="15" fill="rgb(229,163,45)" fg:x="29590" fg:w="321"/><text x="76.4481%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (162 samples, 0.42%)</title><rect x="76.6075%" y="437" width="0.4172%" height="15" fill="rgb(231,110,42)" fg:x="29749" fg:w="162"/><text x="76.8575%" y="447.50"></text></g><g><title>EVP_EncryptUpdate (158 samples, 0.41%)</title><rect x="76.6178%" y="421" width="0.4069%" height="15" fill="rgb(208,170,48)" fg:x="29753" fg:w="158"/><text x="76.8678%" y="431.50"></text></g><g><title>[libcrypto.so.3] (139 samples, 0.36%)</title><rect x="76.6668%" y="405" width="0.3579%" height="15" fill="rgb(239,116,25)" fg:x="29772" fg:w="139"/><text x="76.9168%" y="415.50"></text></g><g><title>[libcrypto.so.3] (108 samples, 0.28%)</title><rect x="76.7466%" y="389" width="0.2781%" height="15" fill="rgb(219,200,50)" fg:x="29803" fg:w="108"/><text x="76.9966%" y="399.50"></text></g><g><title>[libcrypto.so.3] (99 samples, 0.25%)</title><rect x="76.7698%" y="373" width="0.2549%" height="15" fill="rgb(245,200,0)" fg:x="29812" fg:w="99"/><text x="77.0198%" y="383.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="77.0118%" y="357" width="0.0129%" height="15" fill="rgb(245,119,33)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="367.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="77.0118%" y="341" width="0.0129%" height="15" fill="rgb(231,125,12)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="351.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="77.0118%" y="325" width="0.0129%" height="15" fill="rgb(216,96,41)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="335.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="77.0118%" y="309" width="0.0129%" height="15" fill="rgb(248,43,45)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="319.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="77.0118%" y="293" width="0.0129%" height="15" fill="rgb(217,222,7)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="303.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="77.0118%" y="277" width="0.0129%" height="15" fill="rgb(233,28,6)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="287.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="77.0118%" y="261" width="0.0129%" height="15" fill="rgb(231,218,15)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="271.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="77.0118%" y="245" width="0.0129%" height="15" fill="rgb(226,171,48)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="255.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="77.0118%" y="229" width="0.0129%" height="15" fill="rgb(235,201,9)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="239.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="77.0118%" y="213" width="0.0129%" height="15" fill="rgb(217,80,15)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="223.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="77.0118%" y="197" width="0.0129%" height="15" fill="rgb(219,152,8)" fg:x="29906" fg:w="5"/><text x="77.2618%" y="207.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::deref::Deref&gt;::deref (10 samples, 0.03%)</title><rect x="77.0247%" y="437" width="0.0258%" height="15" fill="rgb(243,107,38)" fg:x="29911" fg:w="10"/><text x="77.2747%" y="447.50"></text></g><g><title>[libcrypto.so.3] (174 samples, 0.45%)</title><rect x="77.6118%" y="341" width="0.4481%" height="15" fill="rgb(231,17,5)" fg:x="30139" fg:w="174"/><text x="77.8618%" y="351.50"></text></g><g><title>CRYPTO_gcm128_encrypt (280 samples, 0.72%)</title><rect x="77.3517%" y="357" width="0.7210%" height="15" fill="rgb(209,25,54)" fg:x="30038" fg:w="280"/><text x="77.6017%" y="367.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="78.0599%" y="341" width="0.0129%" height="15" fill="rgb(219,0,2)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="351.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="78.0599%" y="325" width="0.0129%" height="15" fill="rgb(246,9,5)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="335.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="78.0599%" y="309" width="0.0129%" height="15" fill="rgb(226,159,4)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="319.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="78.0599%" y="293" width="0.0129%" height="15" fill="rgb(219,175,34)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="303.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="78.0599%" y="277" width="0.0129%" height="15" fill="rgb(236,10,46)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="287.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="78.0599%" y="261" width="0.0129%" height="15" fill="rgb(240,211,16)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="271.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="78.0599%" y="245" width="0.0129%" height="15" fill="rgb(205,3,43)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="255.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="78.0599%" y="229" width="0.0129%" height="15" fill="rgb(245,7,22)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="239.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="78.0599%" y="213" width="0.0129%" height="15" fill="rgb(239,132,32)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="223.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="78.0599%" y="197" width="0.0129%" height="15" fill="rgb(228,202,34)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="207.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="78.0599%" y="181" width="0.0129%" height="15" fill="rgb(254,200,22)" fg:x="30313" fg:w="5"/><text x="78.3099%" y="191.50"></text></g><g><title>CRYPTO_gcm128_encrypt_ctr32 (476 samples, 1.23%)</title><rect x="78.0728%" y="357" width="1.2258%" height="15" fill="rgb(219,10,39)" fg:x="30318" fg:w="476"/><text x="78.3228%" y="367.50"></text></g><g><title>[libcrypto.so.3] (345 samples, 0.89%)</title><rect x="78.4101%" y="341" width="0.8884%" height="15" fill="rgb(226,210,39)" fg:x="30449" fg:w="345"/><text x="78.6601%" y="351.50"></text></g><g><title>[libcrypto.so.3] (31 samples, 0.08%)</title><rect x="79.2187%" y="325" width="0.0798%" height="15" fill="rgb(208,219,16)" fg:x="30763" fg:w="31"/><text x="79.4687%" y="335.50"></text></g><g><title>CRYPTO_gcm128_setiv (18 samples, 0.05%)</title><rect x="79.2985%" y="357" width="0.0464%" height="15" fill="rgb(216,158,51)" fg:x="30794" fg:w="18"/><text x="79.5485%" y="367.50"></text></g><g><title>[libcrypto.so.3] (15 samples, 0.04%)</title><rect x="79.3063%" y="341" width="0.0386%" height="15" fill="rgb(233,14,44)" fg:x="30797" fg:w="15"/><text x="79.5563%" y="351.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="87.0625%" y="165" width="0.0129%" height="15" fill="rgb(237,97,39)" fg:x="33809" fg:w="5"/><text x="87.3125%" y="175.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::encrypt (3,908 samples, 10.06%)</title><rect x="77.0247%" y="453" width="10.0636%" height="15" fill="rgb(218,198,43)" fg:x="29911" fg:w="3908"/><text x="77.2747%" y="463.50">&lt;zssp::crypto_i..</text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::update (3,898 samples, 10.04%)</title><rect x="77.0504%" y="437" width="10.0379%" height="15" fill="rgb(231,104,20)" fg:x="29921" fg:w="3898"/><text x="77.3004%" y="447.50">zssp::crypto_im..</text></g><g><title>EVP_EncryptUpdate (3,895 samples, 10.03%)</title><rect x="77.0582%" y="421" width="10.0301%" height="15" fill="rgb(254,36,13)" fg:x="29924" fg:w="3895"/><text x="77.3082%" y="431.50">EVP_EncryptUpda..</text></g><g><title>[libcrypto.so.3] (3,844 samples, 9.90%)</title><rect x="77.1895%" y="405" width="9.8988%" height="15" fill="rgb(248,14,50)" fg:x="29975" fg:w="3844"/><text x="77.4395%" y="415.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,838 samples, 9.88%)</title><rect x="77.2050%" y="389" width="9.8833%" height="15" fill="rgb(217,107,29)" fg:x="29981" fg:w="3838"/><text x="77.4550%" y="399.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,819 samples, 9.83%)</title><rect x="77.2539%" y="373" width="9.8344%" height="15" fill="rgb(251,169,33)" fg:x="30000" fg:w="3819"/><text x="77.5039%" y="383.50">[libcrypto.so...</text></g><g><title>[libcrypto.so.3] (3,007 samples, 7.74%)</title><rect x="79.3449%" y="357" width="7.7434%" height="15" fill="rgb(217,108,32)" fg:x="30812" fg:w="3007"/><text x="79.5949%" y="367.50">[libcrypto...</text></g><g><title>[libcrypto.so.3] (2,753 samples, 7.09%)</title><rect x="79.9990%" y="341" width="7.0893%" height="15" fill="rgb(219,66,42)" fg:x="31066" fg:w="2753"/><text x="80.2490%" y="351.50">[libcrypto..</text></g><g><title>asm_sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="87.0625%" y="325" width="0.0258%" height="15" fill="rgb(206,180,7)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="335.50"></text></g><g><title>sysvec_reschedule_ipi (10 samples, 0.03%)</title><rect x="87.0625%" y="309" width="0.0258%" height="15" fill="rgb(208,226,31)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="319.50"></text></g><g><title>irqentry_exit (10 samples, 0.03%)</title><rect x="87.0625%" y="293" width="0.0258%" height="15" fill="rgb(218,26,49)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="303.50"></text></g><g><title>irqentry_exit_to_user_mode (10 samples, 0.03%)</title><rect x="87.0625%" y="277" width="0.0258%" height="15" fill="rgb(233,197,48)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="287.50"></text></g><g><title>exit_to_user_mode_prepare (10 samples, 0.03%)</title><rect x="87.0625%" y="261" width="0.0258%" height="15" fill="rgb(252,181,51)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="271.50"></text></g><g><title>exit_to_user_mode_loop (10 samples, 0.03%)</title><rect x="87.0625%" y="245" width="0.0258%" height="15" fill="rgb(253,90,19)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="255.50"></text></g><g><title>schedule (10 samples, 0.03%)</title><rect x="87.0625%" y="229" width="0.0258%" height="15" fill="rgb(215,171,30)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="239.50"></text></g><g><title>__schedule (10 samples, 0.03%)</title><rect x="87.0625%" y="213" width="0.0258%" height="15" fill="rgb(214,222,9)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="223.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="87.0625%" y="197" width="0.0258%" height="15" fill="rgb(223,3,22)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="207.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="87.0625%" y="181" width="0.0258%" height="15" fill="rgb(225,196,46)" fg:x="33809" fg:w="10"/><text x="87.3125%" y="191.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="87.0754%" y="165" width="0.0129%" height="15" fill="rgb(209,110,37)" fg:x="33814" fg:w="5"/><text x="87.3254%" y="175.50"></text></g><g><title>core::ptr::drop_in_place&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc&gt; (11 samples, 0.03%)</title><rect x="87.0935%" y="437" width="0.0283%" height="15" fill="rgb(249,89,12)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::crypto_impl::openssl::CipherCtx&gt;&gt; (11 samples, 0.03%)</title><rect x="87.0935%" y="421" width="0.0283%" height="15" fill="rgb(226,27,33)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="431.50"></text></g><g><title>&lt;std::sync::mutex::MutexGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (11 samples, 0.03%)</title><rect x="87.0935%" y="405" width="0.0283%" height="15" fill="rgb(213,82,22)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="415.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::unlock (11 samples, 0.03%)</title><rect x="87.0935%" y="389" width="0.0283%" height="15" fill="rgb(248,140,0)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicU32::swap (11 samples, 0.03%)</title><rect x="87.0935%" y="373" width="0.0283%" height="15" fill="rgb(228,106,3)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_swap (11 samples, 0.03%)</title><rect x="87.0935%" y="357" width="0.0283%" height="15" fill="rgb(209,23,37)" fg:x="33821" fg:w="11"/><text x="87.3435%" y="367.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::finalize (60 samples, 0.15%)</title><rect x="87.1218%" y="437" width="0.1545%" height="15" fill="rgb(241,93,50)" fg:x="33832" fg:w="60"/><text x="87.3718%" y="447.50"></text></g><g><title>EVP_EncryptFinal_ex (60 samples, 0.15%)</title><rect x="87.1218%" y="421" width="0.1545%" height="15" fill="rgb(253,46,43)" fg:x="33832" fg:w="60"/><text x="87.3718%" y="431.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="87.1398%" y="405" width="0.1365%" height="15" fill="rgb(226,206,43)" fg:x="33839" fg:w="53"/><text x="87.3898%" y="415.50"></text></g><g><title>[libcrypto.so.3] (53 samples, 0.14%)</title><rect x="87.1398%" y="389" width="0.1365%" height="15" fill="rgb(217,54,7)" fg:x="33839" fg:w="53"/><text x="87.3898%" y="399.50"></text></g><g><title>[libcrypto.so.3] (48 samples, 0.12%)</title><rect x="87.1527%" y="373" width="0.1236%" height="15" fill="rgb(223,5,52)" fg:x="33844" fg:w="48"/><text x="87.4027%" y="383.50"></text></g><g><title>CRYPTO_gcm128_tag (48 samples, 0.12%)</title><rect x="87.1527%" y="357" width="0.1236%" height="15" fill="rgb(206,52,46)" fg:x="33844" fg:w="48"/><text x="87.4027%" y="367.50"></text></g><g><title>CRYPTO_gcm128_finish (40 samples, 0.10%)</title><rect x="87.1733%" y="341" width="0.1030%" height="15" fill="rgb(253,136,11)" fg:x="33852" fg:w="40"/><text x="87.4233%" y="351.50"></text></g><g><title>[libcrypto.so.3] (26 samples, 0.07%)</title><rect x="87.2093%" y="325" width="0.0670%" height="15" fill="rgb(208,106,33)" fg:x="33866" fg:w="26"/><text x="87.4593%" y="335.50"></text></g><g><title>[libc.so.6] (21 samples, 0.05%)</title><rect x="87.4076%" y="373" width="0.0541%" height="15" fill="rgb(206,54,4)" fg:x="33943" fg:w="21"/><text x="87.6576%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (45 samples, 0.12%)</title><rect x="87.3535%" y="389" width="0.1159%" height="15" fill="rgb(213,3,15)" fg:x="33922" fg:w="45"/><text x="87.6035%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLEnc as zssp::crypto::aes::AesGcmEncContext&gt;::finish (153 samples, 0.39%)</title><rect x="87.0883%" y="453" width="0.3940%" height="15" fill="rgb(252,211,39)" fg:x="33819" fg:w="153"/><text x="87.3383%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::get_tag (80 samples, 0.21%)</title><rect x="87.2763%" y="437" width="0.2060%" height="15" fill="rgb(223,6,36)" fg:x="33892" fg:w="80"/><text x="87.5263%" y="447.50"></text></g><g><title>EVP_CIPHER_CTX_ctrl (79 samples, 0.20%)</title><rect x="87.2789%" y="421" width="0.2034%" height="15" fill="rgb(252,169,45)" fg:x="33893" fg:w="79"/><text x="87.5289%" y="431.50"></text></g><g><title>[libcrypto.so.3] (55 samples, 0.14%)</title><rect x="87.3407%" y="405" width="0.1416%" height="15" fill="rgb(212,48,26)" fg:x="33917" fg:w="55"/><text x="87.5907%" y="415.50"></text></g><g><title>OSSL_PARAM_set_octet_string (5 samples, 0.01%)</title><rect x="87.4694%" y="389" width="0.0129%" height="15" fill="rgb(251,102,48)" fg:x="33967" fg:w="5"/><text x="87.7194%" y="399.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (13 samples, 0.03%)</title><rect x="87.4823%" y="437" width="0.0335%" height="15" fill="rgb(243,208,16)" fg:x="33972" fg:w="13"/><text x="87.7323%" y="447.50"></text></g><g><title>std::sys::unix::locks::futex_mutex::Mutex::lock (13 samples, 0.03%)</title><rect x="87.4823%" y="421" width="0.0335%" height="15" fill="rgb(219,96,24)" fg:x="33972" fg:w="13"/><text x="87.7323%" y="431.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange (13 samples, 0.03%)</title><rect x="87.4823%" y="405" width="0.0335%" height="15" fill="rgb(219,33,29)" fg:x="33972" fg:w="13"/><text x="87.7323%" y="415.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange (13 samples, 0.03%)</title><rect x="87.4823%" y="389" width="0.0335%" height="15" fill="rgb(223,176,5)" fg:x="33972" fg:w="13"/><text x="87.7323%" y="399.50"></text></g><g><title>[libcrypto.so.3] (40 samples, 0.10%)</title><rect x="87.6008%" y="373" width="0.1030%" height="15" fill="rgb(228,140,14)" fg:x="34018" fg:w="40"/><text x="87.8508%" y="383.50"></text></g><g><title>OSSL_PARAM_locate (36 samples, 0.09%)</title><rect x="87.6111%" y="357" width="0.0927%" height="15" fill="rgb(217,179,31)" fg:x="34022" fg:w="36"/><text x="87.8611%" y="367.50"></text></g><g><title>[libc.so.6] (20 samples, 0.05%)</title><rect x="87.6523%" y="341" width="0.0515%" height="15" fill="rgb(230,9,30)" fg:x="34038" fg:w="20"/><text x="87.9023%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_get_iv_length (67 samples, 0.17%)</title><rect x="87.5441%" y="389" width="0.1725%" height="15" fill="rgb(230,136,20)" fg:x="33996" fg:w="67"/><text x="87.7941%" y="399.50"></text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.7038%" y="373" width="0.0129%" height="15" fill="rgb(215,210,22)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="383.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="87.7038%" y="357" width="0.0129%" height="15" fill="rgb(218,43,5)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="367.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="87.7038%" y="341" width="0.0129%" height="15" fill="rgb(216,11,5)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="351.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="87.7038%" y="325" width="0.0129%" height="15" fill="rgb(209,82,29)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="335.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="87.7038%" y="309" width="0.0129%" height="15" fill="rgb(244,115,12)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="319.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="87.7038%" y="293" width="0.0129%" height="15" fill="rgb(222,82,18)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="303.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="87.7038%" y="277" width="0.0129%" height="15" fill="rgb(249,227,8)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="287.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="87.7038%" y="261" width="0.0129%" height="15" fill="rgb(253,141,45)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="271.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="87.7038%" y="245" width="0.0129%" height="15" fill="rgb(234,184,4)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="255.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="87.7038%" y="229" width="0.0129%" height="15" fill="rgb(218,194,23)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="239.50"></text></g><g><title>perf_pmu_nop_void (5 samples, 0.01%)</title><rect x="87.7038%" y="213" width="0.0129%" height="15" fill="rgb(235,66,41)" fg:x="34058" fg:w="5"/><text x="87.9538%" y="223.50"></text></g><g><title>[libc.so.6] (17 samples, 0.04%)</title><rect x="87.8171%" y="341" width="0.0438%" height="15" fill="rgb(245,217,1)" fg:x="34102" fg:w="17"/><text x="88.0671%" y="351.50"></text></g><g><title>OSSL_PARAM_locate (31 samples, 0.08%)</title><rect x="87.7939%" y="357" width="0.0798%" height="15" fill="rgb(229,91,1)" fg:x="34093" fg:w="31"/><text x="88.0439%" y="367.50"></text></g><g><title>strcmp@plt (5 samples, 0.01%)</title><rect x="87.8608%" y="341" width="0.0129%" height="15" fill="rgb(207,101,30)" fg:x="34119" fg:w="5"/><text x="88.1108%" y="351.50"></text></g><g><title>EVP_CIPHER_CTX_set_padding (67 samples, 0.17%)</title><rect x="87.7166%" y="389" width="0.1725%" height="15" fill="rgb(223,82,49)" fg:x="34063" fg:w="67"/><text x="87.9666%" y="399.50"></text></g><g><title>[libcrypto.so.3] (49 samples, 0.13%)</title><rect x="87.7630%" y="373" width="0.1262%" height="15" fill="rgb(218,167,17)" fg:x="34081" fg:w="49"/><text x="88.0130%" y="383.50"></text></g><g><title>OSSL_PARAM_locate_const (6 samples, 0.02%)</title><rect x="87.8737%" y="357" width="0.0155%" height="15" fill="rgb(208,103,14)" fg:x="34124" fg:w="6"/><text x="88.1237%" y="367.50"></text></g><g><title>EVP_CIPHER_free (21 samples, 0.05%)</title><rect x="87.8892%" y="389" width="0.0541%" height="15" fill="rgb(238,20,8)" fg:x="34130" fg:w="21"/><text x="88.1392%" y="399.50"></text></g><g><title>&lt;zssp::crypto_impl::openssl::AesGcmOpenSSLPool as zssp::crypto::aes::HighThroughputAesGcmPool&gt;::start_enc (206 samples, 0.53%)</title><rect x="87.4823%" y="453" width="0.5305%" height="15" fill="rgb(218,80,54)" fg:x="33972" fg:w="206"/><text x="87.7323%" y="463.50"></text></g><g><title>zssp::crypto_impl::openssl::CipherCtx::cipher_init (193 samples, 0.50%)</title><rect x="87.5158%" y="437" width="0.4970%" height="15" fill="rgb(240,144,17)" fg:x="33985" fg:w="193"/><text x="87.7658%" y="447.50"></text></g><g><title>EVP_CipherInit_ex (193 samples, 0.50%)</title><rect x="87.5158%" y="421" width="0.4970%" height="15" fill="rgb(245,27,50)" fg:x="33985" fg:w="193"/><text x="87.7658%" y="431.50"></text></g><g><title>[libcrypto.so.3] (193 samples, 0.50%)</title><rect x="87.5158%" y="405" width="0.4970%" height="15" fill="rgb(251,51,7)" fg:x="33985" fg:w="193"/><text x="87.7658%" y="415.50"></text></g><g><title>EVP_CIPHER_up_ref (27 samples, 0.07%)</title><rect x="87.9432%" y="389" width="0.0695%" height="15" fill="rgb(245,217,29)" fg:x="34151" fg:w="27"/><text x="88.1932%" y="399.50"></text></g><g><title>__rdl_alloc (6 samples, 0.02%)</title><rect x="88.0179%" y="277" width="0.0155%" height="15" fill="rgb(221,176,29)" fg:x="34180" fg:w="6"/><text x="88.2679%" y="287.50"></text></g><g><title>std::sys::unix::alloc::&lt;impl core::alloc::global::GlobalAlloc for std::alloc::System&gt;::alloc (6 samples, 0.02%)</title><rect x="88.0179%" y="261" width="0.0155%" height="15" fill="rgb(212,180,24)" fg:x="34180" fg:w="6"/><text x="88.2679%" y="271.50"></text></g><g><title>[libc.so.6] (60 samples, 0.15%)</title><rect x="92.2360%" y="245" width="0.1545%" height="15" fill="rgb(254,24,2)" fg:x="35818" fg:w="60"/><text x="92.4860%" y="255.50"></text></g><g><title>[libc.so.6] (978 samples, 2.52%)</title><rect x="89.8875%" y="261" width="2.5185%" height="15" fill="rgb(230,100,2)" fg:x="34906" fg:w="978"/><text x="90.1375%" y="271.50">[l..</text></g><g><title>asm_sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="92.3931%" y="245" width="0.0129%" height="15" fill="rgb(219,142,25)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="255.50"></text></g><g><title>sysvec_reschedule_ipi (5 samples, 0.01%)</title><rect x="92.3931%" y="229" width="0.0129%" height="15" fill="rgb(240,73,43)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="239.50"></text></g><g><title>irqentry_exit (5 samples, 0.01%)</title><rect x="92.3931%" y="213" width="0.0129%" height="15" fill="rgb(214,114,15)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="223.50"></text></g><g><title>irqentry_exit_to_user_mode (5 samples, 0.01%)</title><rect x="92.3931%" y="197" width="0.0129%" height="15" fill="rgb(207,130,4)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="207.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="92.3931%" y="181" width="0.0129%" height="15" fill="rgb(221,25,40)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="191.50"></text></g><g><title>exit_to_user_mode_loop (5 samples, 0.01%)</title><rect x="92.3931%" y="165" width="0.0129%" height="15" fill="rgb(241,184,7)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="175.50"></text></g><g><title>schedule (5 samples, 0.01%)</title><rect x="92.3931%" y="149" width="0.0129%" height="15" fill="rgb(235,159,4)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="159.50"></text></g><g><title>__schedule (5 samples, 0.01%)</title><rect x="92.3931%" y="133" width="0.0129%" height="15" fill="rgb(214,87,48)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="143.50"></text></g><g><title>finish_task_switch.isra.0 (5 samples, 0.01%)</title><rect x="92.3931%" y="117" width="0.0129%" height="15" fill="rgb(246,198,24)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="127.50"></text></g><g><title>__perf_event_task_sched_in (5 samples, 0.01%)</title><rect x="92.3931%" y="101" width="0.0129%" height="15" fill="rgb(209,66,40)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="111.50"></text></g><g><title>perf_ctx_enable (5 samples, 0.01%)</title><rect x="92.3931%" y="85" width="0.0129%" height="15" fill="rgb(233,147,39)" fg:x="35879" fg:w="5"/><text x="92.6431%" y="95.50"></text></g><g><title>__entry_text_start (4 samples, 0.01%)</title><rect x="92.4497%" y="245" width="0.0103%" height="15" fill="rgb(231,145,52)" fg:x="35901" fg:w="4"/><text x="92.6997%" y="255.50"></text></g><g><title>__get_user_nocheck_4 (14 samples, 0.04%)</title><rect x="92.4703%" y="149" width="0.0361%" height="15" fill="rgb(206,20,26)" fg:x="35909" fg:w="14"/><text x="92.7203%" y="159.50"></text></g><g><title>futex_q_lock (5 samples, 0.01%)</title><rect x="92.5167%" y="149" width="0.0129%" height="15" fill="rgb(238,220,4)" fg:x="35927" fg:w="5"/><text x="92.7667%" y="159.50"></text></g><g><title>futex_q_unlock (17 samples, 0.04%)</title><rect x="92.5295%" y="149" width="0.0438%" height="15" fill="rgb(252,195,42)" fg:x="35932" fg:w="17"/><text x="92.7795%" y="159.50"></text></g><g><title>futex_wait (45 samples, 0.12%)</title><rect x="92.4600%" y="181" width="0.1159%" height="15" fill="rgb(209,10,6)" fg:x="35905" fg:w="45"/><text x="92.7100%" y="191.50"></text></g><g><title>futex_wait_setup (42 samples, 0.11%)</title><rect x="92.4677%" y="165" width="0.1082%" height="15" fill="rgb(229,3,52)" fg:x="35908" fg:w="42"/><text x="92.7177%" y="175.50"></text></g><g><title>do_futex (46 samples, 0.12%)</title><rect x="92.4600%" y="197" width="0.1185%" height="15" fill="rgb(253,49,37)" fg:x="35905" fg:w="46"/><text x="92.7100%" y="207.50"></text></g><g><title>__x64_sys_futex (47 samples, 0.12%)</title><rect x="92.4600%" y="213" width="0.1210%" height="15" fill="rgb(240,103,49)" fg:x="35905" fg:w="47"/><text x="92.7100%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (52 samples, 0.13%)</title><rect x="92.4600%" y="245" width="0.1339%" height="15" fill="rgb(250,182,30)" fg:x="35905" fg:w="52"/><text x="92.7100%" y="255.50"></text></g><g><title>do_syscall_64 (52 samples, 0.13%)</title><rect x="92.4600%" y="229" width="0.1339%" height="15" fill="rgb(248,8,30)" fg:x="35905" fg:w="52"/><text x="92.7100%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (5 samples, 0.01%)</title><rect x="92.5811%" y="213" width="0.0129%" height="15" fill="rgb(237,120,30)" fg:x="35952" fg:w="5"/><text x="92.8311%" y="223.50"></text></g><g><title>exit_to_user_mode_prepare (5 samples, 0.01%)</title><rect x="92.5811%" y="197" width="0.0129%" height="15" fill="rgb(221,146,34)" fg:x="35952" fg:w="5"/><text x="92.8311%" y="207.50"></text></g><g><title>__lll_lock_wait_private (74 samples, 0.19%)</title><rect x="92.4059%" y="261" width="0.1906%" height="15" fill="rgb(242,55,13)" fg:x="35884" fg:w="74"/><text x="92.6559%" y="271.50"></text></g><g><title>__entry_text_start (10 samples, 0.03%)</title><rect x="92.6068%" y="245" width="0.0258%" height="15" fill="rgb(242,112,31)" fg:x="35962" fg:w="10"/><text x="92.8568%" y="255.50"></text></g><g><title>futex_hash (7 samples, 0.02%)</title><rect x="92.6506%" y="181" width="0.0180%" height="15" fill="rgb(249,192,27)" fg:x="35979" fg:w="7"/><text x="92.9006%" y="191.50"></text></g><g><title>_raw_spin_lock (8 samples, 0.02%)</title><rect x="92.7587%" y="165" width="0.0206%" height="15" fill="rgb(208,204,44)" fg:x="36021" fg:w="8"/><text x="93.0087%" y="175.50"></text></g><g><title>native_queued_spin_lock_slowpath (8 samples, 0.02%)</title><rect x="92.7587%" y="149" width="0.0206%" height="15" fill="rgb(208,93,54)" fg:x="36021" fg:w="8"/><text x="93.0087%" y="159.50"></text></g><g><title>futex_wake_mark (10 samples, 0.03%)</title><rect x="92.7819%" y="165" width="0.0258%" height="15" fill="rgb(242,1,31)" fg:x="36030" fg:w="10"/><text x="93.0319%" y="175.50"></text></g><g><title>wake_q_add_safe (4 samples, 0.01%)</title><rect x="92.8128%" y="165" width="0.0103%" height="15" fill="rgb(241,83,25)" fg:x="36042" fg:w="4"/><text x="93.0628%" y="175.50"></text></g><g><title>__smp_call_single_queue (12 samples, 0.03%)</title><rect x="92.9750%" y="117" width="0.0309%" height="15" fill="rgb(205,169,50)" fg:x="36105" fg:w="12"/><text x="93.2250%" y="127.50"></text></g><g><title>native_send_call_func_single_ipi (8 samples, 0.02%)</title><rect x="92.9853%" y="101" width="0.0206%" height="15" fill="rgb(239,186,37)" fg:x="36109" fg:w="8"/><text x="93.2353%" y="111.50"></text></g><g><title>x2apic_send_IPI (7 samples, 0.02%)</title><rect x="92.9879%" y="85" width="0.0180%" height="15" fill="rgb(205,221,10)" fg:x="36110" fg:w="7"/><text x="93.2379%" y="95.50"></text></g><g><title>native_write_msr (5 samples, 0.01%)</title><rect x="92.9931%" y="69" width="0.0129%" height="15" fill="rgb(218,196,15)" fg:x="36112" fg:w="5"/><text x="93.2431%" y="79.50"></text></g><g><title>llist_add_batch (10 samples, 0.03%)</title><rect x="93.0059%" y="117" width="0.0258%" height="15" fill="rgb(218,196,35)" fg:x="36117" fg:w="10"/><text x="93.2559%" y="127.50"></text></g><g><title>try_to_wake_up (77 samples, 0.20%)</title><rect x="92.8411%" y="149" width="0.1983%" height="15" fill="rgb(233,63,24)" fg:x="36053" fg:w="77"/><text x="93.0911%" y="159.50"></text></g><g><title>ttwu_queue_wakelist (37 samples, 0.10%)</title><rect x="92.9441%" y="133" width="0.0953%" height="15" fill="rgb(225,8,4)" fg:x="36093" fg:w="37"/><text x="93.1941%" y="143.50"></text></g><g><title>futex_wake (145 samples, 0.37%)</title><rect x="92.6686%" y="181" width="0.3734%" height="15" fill="rgb(234,105,35)" fg:x="35986" fg:w="145"/><text x="92.9186%" y="191.50"></text></g><g><title>wake_up_q (85 samples, 0.22%)</title><rect x="92.8231%" y="165" width="0.2189%" height="15" fill="rgb(236,21,32)" fg:x="36046" fg:w="85"/><text x="93.0731%" y="175.50"></text></g><g><title>do_futex (158 samples, 0.41%)</title><rect x="92.6403%" y="197" width="0.4069%" height="15" fill="rgb(228,109,6)" fg:x="35975" fg:w="158"/><text x="92.8903%" y="207.50"></text></g><g><title>__x64_sys_futex (159 samples, 0.41%)</title><rect x="92.6403%" y="213" width="0.4094%" height="15" fill="rgb(229,215,31)" fg:x="35975" fg:w="159"/><text x="92.8903%" y="223.50"></text></g><g><title>exit_to_user_mode_prepare (6 samples, 0.02%)</title><rect x="93.0626%" y="197" width="0.0155%" height="15" fill="rgb(221,52,54)" fg:x="36139" fg:w="6"/><text x="93.3126%" y="207.50"></text></g><g><title>do_syscall_64 (172 samples, 0.44%)</title><rect x="92.6377%" y="229" width="0.4429%" height="15" fill="rgb(252,129,43)" fg:x="35974" fg:w="172"/><text x="92.8877%" y="239.50"></text></g><g><title>syscall_exit_to_user_mode (8 samples, 0.02%)</title><rect x="93.0600%" y="213" width="0.0206%" height="15" fill="rgb(248,183,27)" fg:x="36138" fg:w="8"/><text x="93.3100%" y="223.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (175 samples, 0.45%)</title><rect x="92.6326%" y="245" width="0.4506%" height="15" fill="rgb(250,0,22)" fg:x="35972" fg:w="175"/><text x="92.8826%" y="255.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (1,972 samples, 5.08%)</title><rect x="88.0128%" y="373" width="5.0782%" height="15" fill="rgb(213,166,10)" fg:x="34178" fg:w="1972"/><text x="88.2628%" y="383.50">alloc:..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (1,972 samples, 5.08%)</title><rect x="88.0128%" y="357" width="5.0782%" height="15" fill="rgb(207,163,36)" fg:x="34178" fg:w="1972"/><text x="88.2628%" y="367.50">alloc:..</text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (1,972 samples, 5.08%)</title><rect x="88.0128%" y="341" width="5.0782%" height="15" fill="rgb(208,122,22)" fg:x="34178" fg:w="1972"/><text x="88.2628%" y="351.50">alloc:..</text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (1,970 samples, 5.07%)</title><rect x="88.0179%" y="325" width="5.0730%" height="15" fill="rgb(207,104,49)" fg:x="34180" fg:w="1970"/><text x="88.2679%" y="335.50">&lt;alloc..</text></g><g><title>alloc::alloc::Global::alloc_impl (1,970 samples, 5.07%)</title><rect x="88.0179%" y="309" width="5.0730%" height="15" fill="rgb(248,211,50)" fg:x="34180" fg:w="1970"/><text x="88.2679%" y="319.50">alloc:..</text></g><g><title>alloc::alloc::alloc (1,970 samples, 5.07%)</title><rect x="88.0179%" y="293" width="5.0730%" height="15" fill="rgb(217,13,45)" fg:x="34180" fg:w="1970"/><text x="88.2679%" y="303.50">alloc:..</text></g><g><title>malloc (1,962 samples, 5.05%)</title><rect x="88.0385%" y="277" width="5.0524%" height="15" fill="rgb(211,216,49)" fg:x="34188" fg:w="1962"/><text x="88.2885%" y="287.50">malloc</text></g><g><title>__lll_lock_wake_private (192 samples, 0.49%)</title><rect x="92.5965%" y="261" width="0.4944%" height="15" fill="rgb(221,58,53)" fg:x="35958" fg:w="192"/><text x="92.8465%" y="271.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (2,175 samples, 5.60%)</title><rect x="88.0128%" y="437" width="5.6009%" height="15" fill="rgb(220,112,41)" fg:x="34178" fg:w="2175"/><text x="88.2628%" y="447.50">alloc::..</text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (2,175 samples, 5.60%)</title><rect x="88.0128%" y="421" width="5.6009%" height="15" fill="rgb(236,38,28)" fg:x="34178" fg:w="2175"/><text x="88.2628%" y="431.50">alloc::..</text></g><g><title>alloc::slice::hack::to_vec (2,175 samples, 5.60%)</title><rect x="88.0128%" y="405" width="5.6009%" height="15" fill="rgb(227,195,22)" fg:x="34178" fg:w="2175"/><text x="88.2628%" y="415.50">alloc::..</text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (2,175 samples, 5.60%)</title><rect x="88.0128%" y="389" width="5.6009%" height="15" fill="rgb(214,55,33)" fg:x="34178" fg:w="2175"/><text x="88.2628%" y="399.50">&lt;T as a..</text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (203 samples, 0.52%)</title><rect x="93.0909%" y="373" width="0.5228%" height="15" fill="rgb(248,80,13)" fg:x="36150" fg:w="203"/><text x="93.3409%" y="383.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (203 samples, 0.52%)</title><rect x="93.0909%" y="357" width="0.5228%" height="15" fill="rgb(238,52,6)" fg:x="36150" fg:w="203"/><text x="93.3409%" y="367.50"></text></g><g><title>[libc.so.6] (201 samples, 0.52%)</title><rect x="93.0961%" y="341" width="0.5176%" height="15" fill="rgb(224,198,47)" fg:x="36152" fg:w="201"/><text x="93.3461%" y="351.50"></text></g><g><title>core::sync::atomic::AtomicUsize::compare_exchange_weak (118 samples, 0.30%)</title><rect x="97.7339%" y="373" width="0.3039%" height="15" fill="rgb(233,171,20)" fg:x="37953" fg:w="118"/><text x="97.9839%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (118 samples, 0.30%)</title><rect x="97.7339%" y="357" width="0.3039%" height="15" fill="rgb(241,30,25)" fg:x="37953" fg:w="118"/><text x="97.9839%" y="367.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_send (183 samples, 0.47%)</title><rect x="97.6618%" y="389" width="0.4712%" height="15" fill="rgb(207,171,38)" fg:x="37925" fg:w="183"/><text x="97.9118%" y="399.50"></text></g><g><title>core::sync::atomic::AtomicUsize::load (37 samples, 0.10%)</title><rect x="98.0378%" y="373" width="0.0953%" height="15" fill="rgb(234,70,1)" fg:x="38071" fg:w="37"/><text x="98.2878%" y="383.50"></text></g><g><title>core::sync::atomic::atomic_load (37 samples, 0.10%)</title><rect x="98.0378%" y="357" width="0.0953%" height="15" fill="rgb(232,178,18)" fg:x="38071" fg:w="37"/><text x="98.2878%" y="367.50"></text></g><g><title>core::ptr::mut_ptr::&lt;impl *mut T&gt;::write (7 samples, 0.02%)</title><rect x="98.1459%" y="373" width="0.0180%" height="15" fill="rgb(241,78,40)" fg:x="38113" fg:w="7"/><text x="98.3959%" y="383.50"></text></g><g><title>core::ptr::write (7 samples, 0.02%)</title><rect x="98.1459%" y="357" width="0.0180%" height="15" fill="rgb(222,35,25)" fg:x="38113" fg:w="7"/><text x="98.3959%" y="367.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (3,947 samples, 10.16%)</title><rect x="88.0128%" y="453" width="10.1640%" height="15" fill="rgb(207,92,16)" fg:x="34178" fg:w="3947"/><text x="88.2628%" y="463.50">benchmark::bob_..</text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (1,771 samples, 4.56%)</title><rect x="93.6163%" y="437" width="4.5606%" height="15" fill="rgb(216,59,51)" fg:x="36354" fg:w="1771"/><text x="93.8663%" y="447.50">std::..</text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (1,764 samples, 4.54%)</title><rect x="93.6343%" y="421" width="4.5425%" height="15" fill="rgb(213,80,28)" fg:x="36361" fg:w="1764"/><text x="93.8843%" y="431.50">std::..</text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (219 samples, 0.56%)</title><rect x="97.6129%" y="405" width="0.5640%" height="15" fill="rgb(220,93,7)" fg:x="37906" fg:w="219"/><text x="97.8629%" y="415.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::write (17 samples, 0.04%)</title><rect x="98.1330%" y="389" width="0.0438%" height="15" fill="rgb(225,24,44)" fg:x="38108" fg:w="17"/><text x="98.3830%" y="399.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (5 samples, 0.01%)</title><rect x="98.1639%" y="373" width="0.0129%" height="15" fill="rgb(243,74,40)" fg:x="38120" fg:w="5"/><text x="98.4139%" y="383.50"></text></g><g><title>core::mem::drop (38 samples, 0.10%)</title><rect x="98.1845%" y="453" width="0.0979%" height="15" fill="rgb(228,39,7)" fg:x="38128" fg:w="38"/><text x="98.4345%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::rwlock::RwLockReadGuard&lt;zssp::zeta::MutableState&lt;benchmark::TestApplication&gt;&gt;&gt; (38 samples, 0.10%)</title><rect x="98.1845%" y="437" width="0.0979%" height="15" fill="rgb(227,79,8)" fg:x="38128" fg:w="38"/><text x="98.4345%" y="447.50"></text></g><g><title>&lt;std::sync::rwlock::RwLockReadGuard&lt;T&gt; as core::ops::drop::Drop&gt;::drop (38 samples, 0.10%)</title><rect x="98.1845%" y="421" width="0.0979%" height="15" fill="rgb(236,58,11)" fg:x="38128" fg:w="38"/><text x="98.4345%" y="431.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read_unlock (38 samples, 0.10%)</title><rect x="98.1845%" y="405" width="0.0979%" height="15" fill="rgb(249,63,35)" fg:x="38128" fg:w="38"/><text x="98.4345%" y="415.50"></text></g><g><title>core::sync::atomic::AtomicU32::fetch_sub (36 samples, 0.09%)</title><rect x="98.1897%" y="389" width="0.0927%" height="15" fill="rgb(252,114,16)" fg:x="38130" fg:w="36"/><text x="98.4397%" y="399.50"></text></g><g><title>core::sync::atomic::atomic_sub (36 samples, 0.09%)</title><rect x="98.1897%" y="373" width="0.0927%" height="15" fill="rgb(254,151,24)" fg:x="38130" fg:w="36"/><text x="98.4397%" y="383.50"></text></g><g><title>core::slice::&lt;impl [T]&gt;::copy_from_slice (10 samples, 0.03%)</title><rect x="98.2824%" y="453" width="0.0258%" height="15" fill="rgb(253,54,39)" fg:x="38166" fg:w="10"/><text x="98.5324%" y="463.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (10 samples, 0.03%)</title><rect x="98.2824%" y="437" width="0.0258%" height="15" fill="rgb(243,25,45)" fg:x="38166" fg:w="10"/><text x="98.5324%" y="447.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index (6 samples, 0.02%)</title><rect x="98.3081%" y="437" width="0.0155%" height="15" fill="rgb(234,134,9)" fg:x="38176" fg:w="6"/><text x="98.5581%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::Index&lt;I&gt; for [T]&gt;::index (11 samples, 0.03%)</title><rect x="98.3081%" y="453" width="0.0283%" height="15" fill="rgb(227,166,31)" fg:x="38176" fg:w="11"/><text x="98.5581%" y="463.50"></text></g><g><title>&lt;core::ops::range::RangeFrom&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index (5 samples, 0.01%)</title><rect x="98.3236%" y="437" width="0.0129%" height="15" fill="rgb(245,143,41)" fg:x="38182" fg:w="5"/><text x="98.5736%" y="447.50"></text></g><g><title>core::slice::index::&lt;impl core::ops::index::IndexMut&lt;I&gt; for [T]&gt;::index_mut (5 samples, 0.01%)</title><rect x="98.3365%" y="453" width="0.0129%" height="15" fill="rgb(238,181,32)" fg:x="38187" fg:w="5"/><text x="98.5865%" y="463.50"></text></g><g><title>&lt;core::ops::range::Range&lt;usize&gt; as core::slice::index::SliceIndex&lt;[T]&gt;&gt;::index_mut (5 samples, 0.01%)</title><rect x="98.3365%" y="437" width="0.0129%" height="15" fill="rgb(224,113,18)" fg:x="38187" fg:w="5"/><text x="98.5865%" y="447.50"></text></g><g><title>core::sync::atomic::AtomicU32::compare_exchange_weak (34 samples, 0.09%)</title><rect x="98.3571%" y="421" width="0.0876%" height="15" fill="rgb(240,229,28)" fg:x="38195" fg:w="34"/><text x="98.6071%" y="431.50"></text></g><g><title>core::sync::atomic::atomic_compare_exchange_weak (34 samples, 0.09%)</title><rect x="98.3571%" y="405" width="0.0876%" height="15" fill="rgb(250,185,3)" fg:x="38195" fg:w="34"/><text x="98.6071%" y="415.50"></text></g><g><title>std::sync::rwlock::RwLock&lt;T&gt;::read (38 samples, 0.10%)</title><rect x="98.3493%" y="453" width="0.0979%" height="15" fill="rgb(212,59,25)" fg:x="38192" fg:w="38"/><text x="98.5993%" y="463.50"></text></g><g><title>std::sys::unix::locks::futex_rwlock::RwLock::read (38 samples, 0.10%)</title><rect x="98.3493%" y="437" width="0.0979%" height="15" fill="rgb(221,87,20)" fg:x="38192" fg:w="38"/><text x="98.5993%" y="447.50"></text></g><g><title>benchmark::bob_main (17,970 samples, 46.28%)</title><rect x="52.1927%" y="501" width="46.2751%" height="15" fill="rgb(213,74,28)" fg:x="20268" fg:w="17970"/><text x="52.4427%" y="511.50">benchmark::bob_main</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::send (8,668 samples, 22.32%)</title><rect x="76.1466%" y="485" width="22.3212%" height="15" fill="rgb(224,132,34)" fg:x="29570" fg:w="8668"/><text x="76.3966%" y="495.50">zssp::zssp::Context&lt;Crypto&gt;::send</text></g><g><title>zssp::zeta::send_payload (8,667 samples, 22.32%)</title><rect x="76.1492%" y="469" width="22.3186%" height="15" fill="rgb(222,101,24)" fg:x="29571" fg:w="8667"/><text x="76.3992%" y="479.50">zssp::zeta::send_payload</text></g><g><title>zssp::zeta::get_counter (8 samples, 0.02%)</title><rect x="98.4472%" y="453" width="0.0206%" height="15" fill="rgb(254,142,4)" fg:x="38230" fg:w="8"/><text x="98.6972%" y="463.50"></text></g><g><title>core::sync::atomic::AtomicU64::fetch_add (7 samples, 0.02%)</title><rect x="98.4498%" y="437" width="0.0180%" height="15" fill="rgb(230,229,49)" fg:x="38231" fg:w="7"/><text x="98.6998%" y="447.50"></text></g><g><title>core::sync::atomic::atomic_add (7 samples, 0.02%)</title><rect x="98.4498%" y="421" width="0.0180%" height="15" fill="rgb(238,70,47)" fg:x="38231" fg:w="7"/><text x="98.6998%" y="431.50"></text></g><g><title>cfree (25 samples, 0.06%)</title><rect x="98.4678%" y="501" width="0.0644%" height="15" fill="rgb(231,160,17)" fg:x="38238" fg:w="25"/><text x="98.7178%" y="511.50"></text></g><g><title>clock_gettime (17 samples, 0.04%)</title><rect x="98.5322%" y="501" width="0.0438%" height="15" fill="rgb(218,68,53)" fg:x="38263" fg:w="17"/><text x="98.7822%" y="511.50"></text></g><g><title>core::hash::BuildHasher::hash_one (25 samples, 0.06%)</title><rect x="98.5760%" y="501" width="0.0644%" height="15" fill="rgb(236,111,10)" fg:x="38280" fg:w="25"/><text x="98.8260%" y="511.50"></text></g><g><title>core::hash::impls::&lt;impl core::hash::Hash for &amp;T&gt;::hash (18 samples, 0.05%)</title><rect x="98.5940%" y="485" width="0.0464%" height="15" fill="rgb(224,34,41)" fg:x="38287" fg:w="18"/><text x="98.8440%" y="495.50"></text></g><g><title>core::ptr::drop_in_place&lt;std::sync::mutex::MutexGuard&lt;zssp::fragged::Fragged&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt;&gt; (4 samples, 0.01%)</title><rect x="98.6403%" y="501" width="0.0103%" height="15" fill="rgb(241,118,19)" fg:x="38305" fg:w="4"/><text x="98.8903%" y="511.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::unwrap (10 samples, 0.03%)</title><rect x="98.6506%" y="501" width="0.0258%" height="15" fill="rgb(238,129,25)" fg:x="38309" fg:w="10"/><text x="98.9006%" y="511.50"></text></g><g><title>malloc (11 samples, 0.03%)</title><rect x="98.6764%" y="501" width="0.0283%" height="15" fill="rgb(238,22,31)" fg:x="38319" fg:w="11"/><text x="98.9264%" y="511.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_timeout (25 samples, 0.06%)</title><rect x="98.7047%" y="501" width="0.0644%" height="15" fill="rgb(222,174,48)" fg:x="38330" fg:w="25"/><text x="98.9547%" y="511.50"></text></g><g><title>std::sync::mpmc::Receiver&lt;T&gt;::recv_deadline (10 samples, 0.03%)</title><rect x="98.7433%" y="485" width="0.0258%" height="15" fill="rgb(206,152,40)" fg:x="38345" fg:w="10"/><text x="98.9933%" y="495.50"></text></g><g><title>std::sync::mpmc::Sender&lt;T&gt;::send (13 samples, 0.03%)</title><rect x="98.7691%" y="501" width="0.0335%" height="15" fill="rgb(218,99,54)" fg:x="38355" fg:w="13"/><text x="99.0191%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::recv (28 samples, 0.07%)</title><rect x="98.8026%" y="501" width="0.0721%" height="15" fill="rgb(220,174,26)" fg:x="38368" fg:w="28"/><text x="99.0526%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::send (14 samples, 0.04%)</title><rect x="98.8747%" y="501" width="0.0361%" height="15" fill="rgb(245,116,9)" fg:x="38396" fg:w="14"/><text x="99.1247%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (21 samples, 0.05%)</title><rect x="98.9107%" y="501" width="0.0541%" height="15" fill="rgb(209,72,35)" fg:x="38410" fg:w="21"/><text x="99.1607%" y="511.50"></text></g><g><title>std::sync::mpmc::utils::Backoff::new (22 samples, 0.06%)</title><rect x="98.9648%" y="501" width="0.0567%" height="15" fill="rgb(226,126,21)" fg:x="38431" fg:w="22"/><text x="99.2148%" y="511.50"></text></g><g><title>std::sync::mpmc::waker::SyncWaker::notify (22 samples, 0.06%)</title><rect x="99.0215%" y="501" width="0.0567%" height="15" fill="rgb(227,192,1)" fg:x="38453" fg:w="22"/><text x="99.2715%" y="511.50"></text></g><g><title>core::sync::atomic::AtomicBool::load (5 samples, 0.01%)</title><rect x="99.0652%" y="485" width="0.0129%" height="15" fill="rgb(237,180,29)" fg:x="38470" fg:w="5"/><text x="99.3152%" y="495.50"></text></g><g><title>core::sync::atomic::atomic_load (5 samples, 0.01%)</title><rect x="99.0652%" y="469" width="0.0129%" height="15" fill="rgb(230,197,35)" fg:x="38470" fg:w="5"/><text x="99.3152%" y="479.50"></text></g><g><title>std::sync::mutex::Mutex&lt;T&gt;::lock (9 samples, 0.02%)</title><rect x="99.0807%" y="501" width="0.0232%" height="15" fill="rgb(246,193,31)" fg:x="38476" fg:w="9"/><text x="99.3307%" y="511.50"></text></g><g><title>std::sys::unix::time::Timespec::sub_timespec (9 samples, 0.02%)</title><rect x="99.1039%" y="501" width="0.0232%" height="15" fill="rgb(241,36,4)" fg:x="38485" fg:w="9"/><text x="99.3539%" y="511.50"></text></g><g><title>std::sys::unix::time::inner::&lt;impl std::sys::unix::time::Timespec&gt;::now (9 samples, 0.02%)</title><rect x="99.1270%" y="501" width="0.0232%" height="15" fill="rgb(241,130,17)" fg:x="38494" fg:w="9"/><text x="99.3770%" y="511.50"></text></g><g><title>std::time::SystemTime::checked_add (7 samples, 0.02%)</title><rect x="99.1502%" y="501" width="0.0180%" height="15" fill="rgb(206,137,32)" fg:x="38503" fg:w="7"/><text x="99.4002%" y="511.50"></text></g><g><title>zssp::fragged::Fragged&lt;Fragment,_&gt;::assemble (19 samples, 0.05%)</title><rect x="99.1708%" y="501" width="0.0489%" height="15" fill="rgb(237,228,51)" fg:x="38511" fg:w="19"/><text x="99.4208%" y="511.50"></text></g><g><title>zssp::zeta::from_nonce (8 samples, 0.02%)</title><rect x="99.2197%" y="501" width="0.0206%" height="15" fill="rgb(243,6,42)" fg:x="38530" fg:w="8"/><text x="99.4697%" y="511.50"></text></g><g><title>alloc::vec::Vec&lt;T,A&gt;::with_capacity_in (20 samples, 0.05%)</title><rect x="99.3511%" y="405" width="0.0515%" height="15" fill="rgb(251,74,28)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="415.50"></text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::with_capacity_in (20 samples, 0.05%)</title><rect x="99.3511%" y="389" width="0.0515%" height="15" fill="rgb(218,20,49)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="399.50"></text></g><g><title>alloc::raw_vec::RawVec&lt;T,A&gt;::allocate_in (20 samples, 0.05%)</title><rect x="99.3511%" y="373" width="0.0515%" height="15" fill="rgb(238,28,14)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="383.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::allocate (20 samples, 0.05%)</title><rect x="99.3511%" y="357" width="0.0515%" height="15" fill="rgb(229,40,46)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="367.50"></text></g><g><title>alloc::alloc::Global::alloc_impl (20 samples, 0.05%)</title><rect x="99.3511%" y="341" width="0.0515%" height="15" fill="rgb(244,195,20)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="351.50"></text></g><g><title>alloc::alloc::alloc (20 samples, 0.05%)</title><rect x="99.3511%" y="325" width="0.0515%" height="15" fill="rgb(253,56,35)" fg:x="38581" fg:w="20"/><text x="99.6011%" y="335.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec (29 samples, 0.07%)</title><rect x="99.3511%" y="469" width="0.0747%" height="15" fill="rgb(210,149,44)" fg:x="38581" fg:w="29"/><text x="99.6011%" y="479.50"></text></g><g><title>alloc::slice::&lt;impl [T]&gt;::to_vec_in (29 samples, 0.07%)</title><rect x="99.3511%" y="453" width="0.0747%" height="15" fill="rgb(240,135,12)" fg:x="38581" fg:w="29"/><text x="99.6011%" y="463.50"></text></g><g><title>alloc::slice::hack::to_vec (29 samples, 0.07%)</title><rect x="99.3511%" y="437" width="0.0747%" height="15" fill="rgb(251,24,50)" fg:x="38581" fg:w="29"/><text x="99.6011%" y="447.50"></text></g><g><title>&lt;T as alloc::slice::hack::ConvertVec&gt;::to_vec (29 samples, 0.07%)</title><rect x="99.3511%" y="421" width="0.0747%" height="15" fill="rgb(243,200,47)" fg:x="38581" fg:w="29"/><text x="99.6011%" y="431.50"></text></g><g><title>core::ptr::const_ptr::&lt;impl *const T&gt;::copy_to_nonoverlapping (9 samples, 0.02%)</title><rect x="99.4026%" y="405" width="0.0232%" height="15" fill="rgb(224,166,26)" fg:x="38601" fg:w="9"/><text x="99.6526%" y="415.50"></text></g><g><title>core::intrinsics::copy_nonoverlapping (9 samples, 0.02%)</title><rect x="99.4026%" y="389" width="0.0232%" height="15" fill="rgb(233,0,47)" fg:x="38601" fg:w="9"/><text x="99.6526%" y="399.50"></text></g><g><title>zssp::zeta::send_payload (76 samples, 0.20%)</title><rect x="99.2429%" y="501" width="0.1957%" height="15" fill="rgb(253,80,5)" fg:x="38539" fg:w="76"/><text x="99.4929%" y="511.50"></text></g><g><title>benchmark::bob_main::_{{closure}} (34 samples, 0.09%)</title><rect x="99.3511%" y="485" width="0.0876%" height="15" fill="rgb(214,133,25)" fg:x="38581" fg:w="34"/><text x="99.6011%" y="495.50"></text></g><g><title>std::sync::mpsc::SyncSender&lt;T&gt;::send (5 samples, 0.01%)</title><rect x="99.4257%" y="469" width="0.0129%" height="15" fill="rgb(209,27,14)" fg:x="38610" fg:w="5"/><text x="99.6757%" y="479.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (6 samples, 0.02%)</title><rect x="99.5880%" y="485" width="0.0155%" height="15" fill="rgb(219,102,51)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="495.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (6 samples, 0.02%)</title><rect x="99.5880%" y="469" width="0.0155%" height="15" fill="rgb(237,18,16)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="479.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (6 samples, 0.02%)</title><rect x="99.5880%" y="453" width="0.0155%" height="15" fill="rgb(241,85,17)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (6 samples, 0.02%)</title><rect x="99.5880%" y="437" width="0.0155%" height="15" fill="rgb(236,90,42)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="447.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (6 samples, 0.02%)</title><rect x="99.5880%" y="421" width="0.0155%" height="15" fill="rgb(249,57,21)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (6 samples, 0.02%)</title><rect x="99.5880%" y="405" width="0.0155%" height="15" fill="rgb(243,12,36)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (6 samples, 0.02%)</title><rect x="99.5880%" y="389" width="0.0155%" height="15" fill="rgb(253,128,47)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="399.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (6 samples, 0.02%)</title><rect x="99.5880%" y="373" width="0.0155%" height="15" fill="rgb(207,33,20)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="383.50"></text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (6 samples, 0.02%)</title><rect x="99.5880%" y="357" width="0.0155%" height="15" fill="rgb(233,215,35)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="367.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (6 samples, 0.02%)</title><rect x="99.5880%" y="341" width="0.0155%" height="15" fill="rgb(249,188,52)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="351.50"></text></g><g><title>alloc::alloc::dealloc (6 samples, 0.02%)</title><rect x="99.5880%" y="325" width="0.0155%" height="15" fill="rgb(225,12,32)" fg:x="38673" fg:w="6"/><text x="99.8380%" y="335.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (5 samples, 0.01%)</title><rect x="99.6086%" y="485" width="0.0129%" height="15" fill="rgb(247,98,14)" fg:x="38681" fg:w="5"/><text x="99.8586%" y="495.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (5 samples, 0.01%)</title><rect x="99.6086%" y="469" width="0.0129%" height="15" fill="rgb(247,219,48)" fg:x="38681" fg:w="5"/><text x="99.8586%" y="479.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (5 samples, 0.01%)</title><rect x="99.6086%" y="453" width="0.0129%" height="15" fill="rgb(253,60,48)" fg:x="38681" fg:w="5"/><text x="99.8586%" y="463.50"></text></g><g><title>hashbrown::map::make_hash (5 samples, 0.01%)</title><rect x="99.6086%" y="437" width="0.0129%" height="15" fill="rgb(245,15,52)" fg:x="38681" fg:w="5"/><text x="99.8586%" y="447.50"></text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (78 samples, 0.20%)</title><rect x="99.4412%" y="501" width="0.2009%" height="15" fill="rgb(220,133,28)" fg:x="38616" fg:w="78"/><text x="99.6912%" y="511.50"></text></g><g><title>std::sync::mpmc::array::Channel&lt;T&gt;::start_recv (8 samples, 0.02%)</title><rect x="99.6215%" y="485" width="0.0206%" height="15" fill="rgb(217,180,4)" fg:x="38686" fg:w="8"/><text x="99.8715%" y="495.50"></text></g><g><title>[unknown] (37,624 samples, 96.89%)</title><rect x="2.7734%" y="517" width="96.8867%" height="15" fill="rgb(251,24,1)" fg:x="1077" fg:w="37624"/><text x="3.0234%" y="527.50">[unknown]</text></g><g><title>zssp::zssp::parse_fragment_header (7 samples, 0.02%)</title><rect x="99.6421%" y="501" width="0.0180%" height="15" fill="rgb(212,185,49)" fg:x="38694" fg:w="7"/><text x="99.8921%" y="511.50"></text></g><g><title>EVP_DecryptUpdate (24 samples, 0.06%)</title><rect x="99.6601%" y="501" width="0.0618%" height="15" fill="rgb(215,175,22)" fg:x="38701" fg:w="24"/><text x="99.9101%" y="511.50"></text></g><g><title>__bss_start (26 samples, 0.07%)</title><rect x="99.6601%" y="517" width="0.0670%" height="15" fill="rgb(250,205,14)" fg:x="38701" fg:w="26"/><text x="99.9101%" y="527.50"></text></g><g><title>__rust_probestack (6 samples, 0.02%)</title><rect x="99.7270%" y="517" width="0.0155%" height="15" fill="rgb(225,211,22)" fg:x="38727" fg:w="6"/><text x="99.9770%" y="527.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (7 samples, 0.02%)</title><rect x="99.7528%" y="517" width="0.0180%" height="15" fill="rgb(251,179,42)" fg:x="38737" fg:w="7"/><text x="100.0028%" y="527.50"></text></g><g><title>entry_SYSCALL_64_safe_stack (14 samples, 0.04%)</title><rect x="99.7708%" y="517" width="0.0361%" height="15" fill="rgb(208,216,51)" fg:x="38744" fg:w="14"/><text x="100.0208%" y="527.50"></text></g><g><title>ret_from_fork (10 samples, 0.03%)</title><rect x="99.8069%" y="517" width="0.0258%" height="15" fill="rgb(235,36,11)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="527.50"></text></g><g><title>schedule_tail (10 samples, 0.03%)</title><rect x="99.8069%" y="501" width="0.0258%" height="15" fill="rgb(213,189,28)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="511.50"></text></g><g><title>finish_task_switch.isra.0 (10 samples, 0.03%)</title><rect x="99.8069%" y="485" width="0.0258%" height="15" fill="rgb(227,203,42)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="495.50"></text></g><g><title>__perf_event_task_sched_in (10 samples, 0.03%)</title><rect x="99.8069%" y="469" width="0.0258%" height="15" fill="rgb(244,72,36)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="479.50"></text></g><g><title>perf_ctx_enable (10 samples, 0.03%)</title><rect x="99.8069%" y="453" width="0.0258%" height="15" fill="rgb(213,53,17)" fg:x="38758" fg:w="10"/><text x="100.0569%" y="463.50"></text></g><g><title>core::ptr::drop_in_place&lt;arrayvec::arrayvec::ArrayVec&lt;alloc::vec::Vec&lt;u8&gt;,48_usize&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9588%" y="501" width="0.0129%" height="15" fill="rgb(207,167,3)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="511.50"></text></g><g><title>&lt;arrayvec::arrayvec::ArrayVec&lt;T,_&gt; as core::ops::drop::Drop&gt;::drop (5 samples, 0.01%)</title><rect x="99.9588%" y="485" width="0.0129%" height="15" fill="rgb(216,98,30)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="495.50"></text></g><g><title>arrayvec::arrayvec::ArrayVec&lt;T,_&gt;::clear (5 samples, 0.01%)</title><rect x="99.9588%" y="469" width="0.0129%" height="15" fill="rgb(236,123,15)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="479.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::clear (5 samples, 0.01%)</title><rect x="99.9588%" y="453" width="0.0129%" height="15" fill="rgb(248,81,50)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="463.50"></text></g><g><title>arrayvec::arrayvec_impl::ArrayVecImpl::truncate (5 samples, 0.01%)</title><rect x="99.9588%" y="437" width="0.0129%" height="15" fill="rgb(214,120,4)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="447.50"></text></g><g><title>core::ptr::drop_in_place&lt;[alloc::vec::Vec&lt;u8&gt;]&gt; (5 samples, 0.01%)</title><rect x="99.9588%" y="421" width="0.0129%" height="15" fill="rgb(208,179,34)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="431.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::vec::Vec&lt;u8&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9588%" y="405" width="0.0129%" height="15" fill="rgb(227,140,7)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="415.50"></text></g><g><title>core::ptr::drop_in_place&lt;alloc::raw_vec::RawVec&lt;u8&gt;&gt; (5 samples, 0.01%)</title><rect x="99.9588%" y="389" width="0.0129%" height="15" fill="rgb(214,22,6)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="399.50"></text></g><g><title>&lt;alloc::raw_vec::RawVec&lt;T,A&gt; as core::ops::drop::Drop&gt;::drop (5 samples, 0.01%)</title><rect x="99.9588%" y="373" width="0.0129%" height="15" fill="rgb(207,137,27)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="383.50"></text></g><g><title>&lt;alloc::alloc::Global as core::alloc::Allocator&gt;::deallocate (5 samples, 0.01%)</title><rect x="99.9588%" y="357" width="0.0129%" height="15" fill="rgb(210,8,46)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="367.50"></text></g><g><title>alloc::alloc::dealloc (5 samples, 0.01%)</title><rect x="99.9588%" y="341" width="0.0129%" height="15" fill="rgb(240,16,54)" fg:x="38817" fg:w="5"/><text x="100.2088%" y="351.50"></text></g><g><title>benchmark (38,828 samples, 99.99%)</title><rect x="0.0000%" y="533" width="99.9871%" height="15" fill="rgb(211,209,29)" fg:x="0" fg:w="38828"/><text x="0.2500%" y="543.50">benchmark</text></g><g><title>zssp::zssp::Context&lt;Crypto&gt;::receive (58 samples, 0.15%)</title><rect x="99.8378%" y="517" width="0.1494%" height="15" fill="rgb(226,228,24)" fg:x="38770" fg:w="58"/><text x="100.0878%" y="527.50"></text></g><g><title>std::collections::hash::map::HashMap&lt;K,V,S&gt;::get (6 samples, 0.02%)</title><rect x="99.9717%" y="501" width="0.0155%" height="15" fill="rgb(222,84,9)" fg:x="38822" fg:w="6"/><text x="100.2217%" y="511.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get (6 samples, 0.02%)</title><rect x="99.9717%" y="485" width="0.0155%" height="15" fill="rgb(234,203,30)" fg:x="38822" fg:w="6"/><text x="100.2217%" y="495.50"></text></g><g><title>hashbrown::map::HashMap&lt;K,V,S,A&gt;::get_inner (6 samples, 0.02%)</title><rect x="99.9717%" y="469" width="0.0155%" height="15" fill="rgb(238,109,14)" fg:x="38822" fg:w="6"/><text x="100.2217%" y="479.50"></text></g><g><title>hashbrown::map::make_hash (6 samples, 0.02%)</title><rect x="99.9717%" y="453" width="0.0155%" height="15" fill="rgb(233,206,34)" fg:x="38822" fg:w="6"/><text x="100.2217%" y="463.50"></text></g><g><title>all (38,833 samples, 100%)</title><rect x="0.0000%" y="549" width="100.0000%" height="15" fill="rgb(220,167,47)" fg:x="0" fg:w="38833"/><text x="0.2500%" y="559.50"></text></g><g><title>perf-exec (5 samples, 0.01%)</title><rect x="99.9871%" y="533" width="0.0129%" height="15" fill="rgb(238,105,10)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="543.50"></text></g><g><title>entry_SYSCALL_64_after_hwframe (5 samples, 0.01%)</title><rect x="99.9871%" y="517" width="0.0129%" height="15" fill="rgb(213,227,17)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="527.50"></text></g><g><title>do_syscall_64 (5 samples, 0.01%)</title><rect x="99.9871%" y="501" width="0.0129%" height="15" fill="rgb(217,132,38)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="511.50"></text></g><g><title>__x64_sys_execve (5 samples, 0.01%)</title><rect x="99.9871%" y="485" width="0.0129%" height="15" fill="rgb(242,146,4)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="495.50"></text></g><g><title>do_execveat_common.isra.0 (5 samples, 0.01%)</title><rect x="99.9871%" y="469" width="0.0129%" height="15" fill="rgb(212,61,9)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="479.50"></text></g><g><title>bprm_execve (5 samples, 0.01%)</title><rect x="99.9871%" y="453" width="0.0129%" height="15" fill="rgb(247,126,22)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="463.50"></text></g><g><title>bprm_execve.part.0 (5 samples, 0.01%)</title><rect x="99.9871%" y="437" width="0.0129%" height="15" fill="rgb(220,196,2)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="447.50"></text></g><g><title>exec_binprm (5 samples, 0.01%)</title><rect x="99.9871%" y="421" width="0.0129%" height="15" fill="rgb(208,46,4)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="431.50"></text></g><g><title>search_binary_handler (5 samples, 0.01%)</title><rect x="99.9871%" y="405" width="0.0129%" height="15" fill="rgb(252,104,46)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="415.50"></text></g><g><title>load_elf_binary (5 samples, 0.01%)</title><rect x="99.9871%" y="389" width="0.0129%" height="15" fill="rgb(237,152,48)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="399.50"></text></g><g><title>begin_new_exec (5 samples, 0.01%)</title><rect x="99.9871%" y="373" width="0.0129%" height="15" fill="rgb(221,59,37)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="383.50"></text></g><g><title>perf_event_exec (5 samples, 0.01%)</title><rect x="99.9871%" y="357" width="0.0129%" height="15" fill="rgb(209,202,51)" fg:x="38828" fg:w="5"/><text x="100.2371%" y="367.50"></text></g><g><title>perf_event_enable_on_exec (4 samples, 0.01%)</title><rect x="99.9897%" y="341" width="0.0103%" height="15" fill="rgb(228,81,30)" fg:x="38829" fg:w="4"/><text x="100.2397%" y="351.50"></text></g><g><title>ctx_resched (4 samples, 0.01%)</title><rect x="99.9897%" y="325" width="0.0103%" height="15" fill="rgb(227,42,39)" fg:x="38829" fg:w="4"/><text x="100.2397%" y="335.50"></text></g><g><title>perf_ctx_enable (4 samples, 0.01%)</title><rect x="99.9897%" y="309" width="0.0103%" height="15" fill="rgb(221,26,2)" fg:x="38829" fg:w="4"/><text x="100.2397%" y="319.50"></text></g></svg></svg>
\ No newline at end of file

From 609c352957c003ad3b2fff9ef7877434643c16bf Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Mon, 14 Aug 2023 17:59:14 -0400
Subject: [PATCH 41/50] got rid of extra lines

---
 src/zeta.rs | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/src/zeta.rs b/src/zeta.rs
index cd4ce9a..8af5e23 100644
--- a/src/zeta.rs
+++ b/src/zeta.rs
@@ -1376,13 +1376,8 @@ pub(crate) fn received_k1_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
 
     let i = k1.len() - AES_GCM_TAG_SIZE;
     let tag = k1[i..].try_into().unwrap();
-    if !Crypto::Aead::decrypt_in_place(
-        state.key_ref(false).recv.kek.as_ref().unwrap(),
-        n,
-        &[],
-        &mut k1[..i],
-        &tag,
-    ) {
+    let kek_recv = state.key_ref(false).recv.kek.as_ref().unwrap();
+    if !Crypto::Aead::decrypt_in_place(kek_recv, n, &[], &mut k1[..i], &tag) {
         return Err(fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);
@@ -1527,13 +1522,8 @@ pub(crate) fn received_k2_trans<Crypto: CryptoLayer, App: ApplicationLayer<Crypt
 
     let i = k2.len() - AES_GCM_TAG_SIZE;
     let tag = k2[i..].try_into().unwrap();
-    if !Crypto::Aead::decrypt_in_place(
-        state.key_ref(false).recv.kek.as_ref().unwrap(),
-        n,
-        &[],
-        &mut k2[..i],
-        &tag,
-    ) {
+    let kek_recv = state.key_ref(false).recv.kek.as_ref().unwrap();
+    if !Crypto::Aead::decrypt_in_place(kek_recv, n, &[], &mut k2[..i], &tag) {
         return Err(fault!(FailedAuth, true));
     }
     let (_, c) = from_nonce(n);

From aa80243d06450487fe557ed7de83f1c02bdc5d2f Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 15 Aug 2023 12:11:59 -0400
Subject: [PATCH 42/50] made cipherctx pub

---
 src/crypto_impl/openssl.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/crypto_impl/openssl.rs b/src/crypto_impl/openssl.rs
index ce2b25b..43125ae 100644
--- a/src/crypto_impl/openssl.rs
+++ b/src/crypto_impl/openssl.rs
@@ -7,7 +7,7 @@ use openssl_sys::*;
 
 use crate::crypto::*;
 
-struct CipherCtx(NonNull<openssl_sys::EVP_CIPHER_CTX>);
+pub struct CipherCtx(NonNull<openssl_sys::EVP_CIPHER_CTX>);
 impl Drop for CipherCtx {
     fn drop(&mut self) {
         unsafe {

From ddab1cf216db1d3c853198f3e99381f04cbc4f2f Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Tue, 15 Aug 2023 17:15:29 -0400
Subject: [PATCH 43/50] added kyber update

---
 Cargo.lock                   | 4 ++--
 Cargo.toml                   | 2 +-
 src/crypto_impl/kyber1024.rs | 4 +++-
 src/frag_cache.rs            | 4 ++--
 4 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 50f595c..e1e0058 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -215,9 +215,9 @@ checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
 
 [[package]]
 name = "pqc_kyber"
-version = "0.6.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84c578a7eab95d8649f115dd6f90894d167766e82a6bcf66ff25f60e7dfc857e"
+checksum = "1b5dd33c0b42d244b01ab4f6cabaeb03c3b875017780fb3903b53b9c91fb6663"
 dependencies = [
  "rand_core",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 80513a0..0078064 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,7 +18,7 @@ rand_core = { version = "0.6.4" }
 zeroize = { version = "1.6.0" }
 arrayvec = { version = "0.7.4", default-features = false, features = ["std", "zeroize"] }
 
-pqc_kyber = { version = "0.6.0", default-features = false, features = ["kyber1024", "std"], optional = true }
+pqc_kyber = { version = "0.7.0", default-features = false, features = ["kyber1024", "std"], optional = true }
 p384 = { version = "0.13.0", default-features = false, features = ["ecdh"], optional = true }
 sha2 = { version = "0.10.7", default-features = false, optional = true }
 hmac = { version = "0.12.1", default-features = false, optional = true }
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index feffd5f..4a70105 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -8,7 +8,9 @@ use crate::crypto::*;
 pub type RustKyber1024PrivateKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
 impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for RustKyber1024PrivateKey {
     fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
-        let keypair = pqc_kyber::keypair(rng);
+        // According to the source code this can only fail if the RNG fails.
+        // Idk why rust allows RNG to fail.
+        let keypair = pqc_kyber::keypair(rng).unwrap();
         (Zeroizing::new(keypair.secret), keypair.public)
     }
 
diff --git a/src/frag_cache.rs b/src/frag_cache.rs
index e9f15b9..5fdd804 100644
--- a/src/frag_cache.rs
+++ b/src/frag_cache.rs
@@ -117,7 +117,7 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
         if self.map[idx].key == 0 {
             // This is a new entry so initialize it.
             if (fragment_count as usize) <= self.frags_unused_size {
-                let mut entry = &mut self.map[idx];
+                let entry = &mut self.map[idx];
                 entry.key = key;
                 entry.frags_idx = self.frags_first_unused as u32;
                 entry.fragment_have = 0;
@@ -135,7 +135,7 @@ impl<Fragment> UnassociatedFragCache<Fragment> {
                 return;
             }
         }
-        let mut entry = &mut self.map[idx];
+        let entry = &mut self.map[idx];
 
         let new_size = entry.packet_size + fragment_size as u32;
         let got = 1u64.wrapping_shl(fragment_no as u32);

From 49bc88d0e6bc23ad26e3aacbe8b87a153451fa8d Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 16 Aug 2023 11:16:47 -0400
Subject: [PATCH 44/50] added a pool

---
 examples/benchmark.rs | 79 +++++++++++++++++++++++++++++--------------
 1 file changed, 53 insertions(+), 26 deletions(-)

diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index b2ec3fb..b3be688 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -1,5 +1,5 @@
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{mpsc, Arc};
+use std::sync::{mpsc, Arc, Mutex};
 use std::thread;
 use std::time::{Duration, Instant};
 
@@ -13,7 +13,6 @@ use zssp::application::{
 };
 use zssp::crypto::P384KeyPair;
 use zssp::crypto_impl::*;
-use zssp::result::ReceiveError;
 use zssp::Session;
 
 const TEST_MTU: usize = 1500;
@@ -22,6 +21,34 @@ struct TestApplication {
     time: Instant,
 }
 
+struct PooledVec(Vec<u8>);
+static POOL: Mutex<Vec<Vec<u8>>> = Mutex::new(Vec::new());
+fn alloc(b: &[u8]) -> PooledVec {
+    let mut p = POOL.lock().unwrap();
+    let mut v = p.pop().unwrap_or_default();
+    v.extend(b);
+    PooledVec(v)
+}
+impl Drop for PooledVec {
+    fn drop(&mut self) {
+        let mut p = POOL.lock().unwrap();
+        let mut v = Vec::new();
+        std::mem::swap(&mut self.0, &mut v);
+        v.clear();
+        p.push(v);
+    }
+}
+impl AsMut<[u8]> for PooledVec {
+    fn as_mut(&mut self) -> &mut [u8] {
+        self.0.as_mut()
+    }
+}
+impl AsRef<[u8]> for PooledVec {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
 #[allow(unused)]
 impl CryptoLayer for TestApplication {
     type Rng = OsRng;
@@ -37,7 +64,7 @@ impl CryptoLayer for TestApplication {
 
     type SessionData = ();
 
-    type IncomingPacketBuffer = Vec<u8>;
+    type IncomingPacketBuffer = PooledVec;
 }
 #[allow(unused)]
 impl ApplicationLayer for &TestApplication {
@@ -97,8 +124,8 @@ impl ApplicationLayer for &TestApplication {
 fn alice_main(
     run: &AtomicBool,
     alice_app: &TestApplication,
-    alice_out: mpsc::SyncSender<Vec<u8>>,
-    alice_in: mpsc::Receiver<Vec<u8>>,
+    alice_out: mpsc::SyncSender<PooledVec>,
+    alice_in: mpsc::Receiver<PooledVec>,
     alice_keypair: P384CrateKeyPair,
     bob_pubkey: P384CratePublicKey,
 ) {
@@ -113,7 +140,7 @@ fn alice_main(
         context
             .open(
                 alice_app,
-                |b| alice_out.send(b.to_vec()).is_ok(),
+                |b| alice_out.send(alloc(b)).is_ok(),
                 TEST_MTU,
                 bob_pubkey.clone(),
                 (),
@@ -132,9 +159,9 @@ fn alice_main(
                 output_data.clear();
                 match context.receive(
                     alice_app,
-                    |b| alice_out.send(b.to_vec()).is_ok(),
+                    |b| alice_out.send(alloc(b)).is_ok(),
                     TEST_MTU,
-                    |_| Some((|b: &mut [u8]| alice_out.send(b.to_vec()).is_ok(), TEST_MTU)),
+                    |_| Some((|b: &mut [u8]| alice_out.send(alloc(b)).is_ok(), TEST_MTU)),
                     &0,
                     pkt,
                     &mut output_data,
@@ -154,10 +181,10 @@ fn alice_main(
                         _ => panic!(),
                     },
                     Err(e) => {
-                        println!("[alice] ERROR {:?}", e);
-                        if let ReceiveError::ByzantineFault { unnatural, .. } = e {
-                            assert!(!unnatural)
-                        }
+                        //println!("[alice] ERROR {:?}", e);
+                        //if let ReceiveError::ByzantineFault { unnatural, .. } = e {
+                        //    assert!(!unnatural)
+                        //}
                     }
                 }
             } else {
@@ -169,7 +196,7 @@ fn alice_main(
             context
                 .send(
                     alice_session.as_ref().unwrap(),
-                    |b| alice_out.send(b.to_vec()).is_ok(),
+                    |b| alice_out.send(alloc(b)).is_ok(),
                     &mut [0u8; TEST_MTU],
                     &test_data[..1400 + ((OsRng.next_u64() as usize) % (test_data.len() - 1400))],
                 )
@@ -181,7 +208,7 @@ fn alice_main(
         if current_time >= next_service {
             next_service = current_time
                 + context.service(alice_app, |_| {
-                    Some((|b: &mut [u8]| alice_out.send(b.to_vec()).is_ok(), TEST_MTU))
+                    Some((|b: &mut [u8]| alice_out.send(alloc(b)).is_ok(), TEST_MTU))
                 });
         }
     }
@@ -191,8 +218,8 @@ fn alice_main(
 fn bob_main(
     run: &AtomicBool,
     bob_app: &TestApplication,
-    bob_out: mpsc::SyncSender<Vec<u8>>,
-    bob_in: mpsc::Receiver<Vec<u8>>,
+    bob_out: mpsc::SyncSender<PooledVec>,
+    bob_in: mpsc::Receiver<PooledVec>,
     bob_keypair: P384CrateKeyPair,
 ) {
     let startup_time = std::time::Instant::now();
@@ -214,9 +241,9 @@ fn bob_main(
             output_data.clear();
             match context.receive(
                 bob_app,
-                |b| bob_out.send(b.to_vec()).is_ok(),
+                |b| bob_out.send(alloc(b)).is_ok(),
                 TEST_MTU,
-                |_| Some((|b: &mut [u8]| bob_out.send(b.to_vec()).is_ok(), TEST_MTU)),
+                |_| Some((|b: &mut [u8]| bob_out.send(alloc(b)).is_ok(), TEST_MTU)),
                 &0,
                 pkt,
                 &mut output_data,
@@ -234,7 +261,7 @@ fn bob_main(
                         context
                             .send(
                                 &s,
-                                |b| bob_out.send(b.to_vec()).is_ok(),
+                                |b| bob_out.send(alloc(b)).is_ok(),
                                 &mut [0u8; TEST_MTU],
                                 &output_data,
                             )
@@ -244,10 +271,10 @@ fn bob_main(
                     _ => panic!(),
                 },
                 Err(e) => {
-                    println!("[bob] ERROR {:?}", e);
-                    if let ReceiveError::ByzantineFault { unnatural, .. } = e {
-                        assert!(!unnatural)
-                    }
+                    //println!("[bob] ERROR {:?}", e);
+                    //if let ReceiveError::ByzantineFault { unnatural, .. } = e {
+                    //    assert!(!unnatural)
+                    //}
                 }
             }
         }
@@ -265,7 +292,7 @@ fn bob_main(
         if current_time >= next_service {
             next_service = current_time
                 + context.service(bob_app, |_| {
-                    Some((|b: &mut [u8]| bob_out.send(b.to_vec()).is_ok(), TEST_MTU))
+                    Some((|b: &mut [u8]| bob_out.send(alloc(b)).is_ok(), TEST_MTU))
                 });
         }
     }
@@ -280,8 +307,8 @@ fn core(time: u64) {
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication { time: Instant::now() };
 
-    let (alice_out, bob_in) = mpsc::sync_channel::<Vec<u8>>(256);
-    let (bob_out, alice_in) = mpsc::sync_channel::<Vec<u8>>(256);
+    let (alice_out, bob_in) = mpsc::sync_channel::<PooledVec>(256);
+    let (bob_out, alice_in) = mpsc::sync_channel::<PooledVec>(256);
 
     thread::scope(|ts| {
         {

From fea819601af64964196f94194fbbc28a234e52a9 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 16 Aug 2023 11:35:46 -0400
Subject: [PATCH 45/50] added docs for benchmark fix

---
 examples/benchmark.rs | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index b3be688..58e5534 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -14,6 +14,7 @@ use zssp::application::{
 use zssp::crypto::P384KeyPair;
 use zssp::crypto_impl::*;
 use zssp::Session;
+use zssp::result::ReceiveError;
 
 const TEST_MTU: usize = 1500;
 
@@ -21,6 +22,8 @@ struct TestApplication {
     time: Instant,
 }
 
+/// We have to pool allocations or else variations in the speed of the memory allocator will bias
+/// our performance stats.
 struct PooledVec(Vec<u8>);
 static POOL: Mutex<Vec<Vec<u8>>> = Mutex::new(Vec::new());
 fn alloc(b: &[u8]) -> PooledVec {
@@ -181,10 +184,10 @@ fn alice_main(
                         _ => panic!(),
                     },
                     Err(e) => {
-                        //println!("[alice] ERROR {:?}", e);
-                        //if let ReceiveError::ByzantineFault { unnatural, .. } = e {
-                        //    assert!(!unnatural)
-                        //}
+                        println!("[alice] ERROR {:?}", e);
+                        if let ReceiveError::ByzantineFault { unnatural, .. } = e {
+                            assert!(!unnatural)
+                        }
                     }
                 }
             } else {
@@ -271,10 +274,10 @@ fn bob_main(
                     _ => panic!(),
                 },
                 Err(e) => {
-                    //println!("[bob] ERROR {:?}", e);
-                    //if let ReceiveError::ByzantineFault { unnatural, .. } = e {
-                    //    assert!(!unnatural)
-                    //}
+                    println!("[bob] ERROR {:?}", e);
+                    if let ReceiveError::ByzantineFault { unnatural, .. } = e {
+                        assert!(!unnatural)
+                    }
                 }
             }
         }

From 4c3861624e728d7a116540cc2402f4c8e004420a Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 16 Aug 2023 11:52:55 -0400
Subject: [PATCH 46/50] updated docs

---
 src/zssp.rs | 31 ++++++-------------------------
 1 file changed, 6 insertions(+), 25 deletions(-)

diff --git a/src/zssp.rs b/src/zssp.rs
index 27b24a6..91f8e66 100644
--- a/src/zssp.rs
+++ b/src/zssp.rs
@@ -131,12 +131,10 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
     /// * `send` - Function to be called to send one or more initial packets to the remote being
     ///   contacted
     /// * `mtu` - MTU for initial packets
-    /// * `remote_static_key` - Remote side's static public NIST P-384 key
-    /// * `application_data` - Arbitrary data meaningful to the application to include with session
+    /// * `static_remote_key` - Remote side's static public NIST P-384 key
+    /// * `session_data` - Arbitrary data meaningful to the application to include with session
     ///   object
-    /// * `ratchet_state` - The last saved and confirmed ratchet state associated with this remote
-    ///   peer, or None if we do not have one.
-    /// * `local_identity_blob` - Payload to be sent to Bob that contains the information necessary
+    /// * `identity` - Payload to be sent to Bob that contains the information necessary
     ///   for the upper protocol to authenticate and approve of Alice's identity.
     pub fn open<App: ApplicationLayer<Crypto = Crypto>>(
         &self,
@@ -176,25 +174,12 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
     /// session and will always result in a new session ReceiveOk being returned.
     ///
     /// * `app` - Interface to application using ZSSP
-    /// * `check_allow_incoming_session` - Function to call to check whether an unidentified new
-    ///   session should be accepted
-    /// * `check_accept_session` - Function to accept sessions after final negotiation.
-    ///   The second argument is the identity blob that the remote peer sent us. The application
-    ///   must verify this identity is associated with the remote peer's static key.
-    ///   The third argument is the ratchet chain length, or ratchet count.
-    ///   To prevent desync, if this function returns (Some(_), _), no other open session with the
-    ///   same remote peer must exist.
     /// * `send_unassociated_reply` - Function to send reply packets directly when no session exists
     /// * `send_unassociated_mtu` - MTU for unassociated replies
     /// * `send_to` - Function to get senders for existing sessions, permitting MTU and path lookup
     /// * `remote_address` - Whatever the remote address is, as long as you can Hash it
-    /// * `data_buf` - Buffer to receive decrypted and authenticated object data (an error is
-    ///   returned if too small)
-    /// * `incoming_physical_packet_buf` - Buffer containing incoming wire packet
-    ///   (receive() takes ownership)
-    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
-    ///   with the remote peer. Used to check the state of local offers we may currently have or want
-    ///   to put in-flight.
+    /// * `incoming_fragment_buf` - Buffer containing incoming wire packet (the context takes ownership)
+    /// * `output_buffer` - Buffer to receive decrypted and authenticated object data
     pub fn receive<'a, App: ApplicationLayer<Crypto = Crypto>, SendFn: FnMut(&mut [u8]) -> bool>(
         &self,
         mut app: App,
@@ -605,7 +590,6 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
     ///   slice of `data`
     /// * `mtu_sized_buffer` - A writable work buffer whose size equals the MTU
     /// * `data` - Data to send
-    /// * `current_time` - Current time in milliseconds
     pub fn send(
         &self,
         session: &Arc<Session<Crypto>>,
@@ -622,11 +606,8 @@ impl<Crypto: CryptoLayer> Context<Crypto> {
     /// try to satisfy this but small variations in timing of up to +/- a second or two are not
     /// a problem.
     ///
+    /// * `app` - Interface to application using ZSSP
     /// * `send_to` - Function to get a sender and an MTU to send something over an active session
-    /// * `current_time` - Current time in milliseconds. Does not have to be monotonic, nor synced
-    ///   with remote peers (although both of these properties would help reliability slightly).
-    ///   Used to determine if any current handshakes should be resent or timed-out, or if a session
-    ///   should rekey.
     pub fn service<App: ApplicationLayer<Crypto = Crypto>, SendFn: FnMut(&mut [u8]) -> bool>(
         &self,
         mut app: App,

From 9604f8268abd3b8bdf8ff3b7d9b63698002aa405 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 16 Aug 2023 11:53:57 -0400
Subject: [PATCH 47/50] fixed .gitignore

---
 .gitignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index c3a4a94..b3dabfd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
 /target
 perf*.data
 perf*.old
-.svg
+*.svg

From 5739911ddd827001119333033297ce5340c065ff Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 16 Aug 2023 12:05:51 -0400
Subject: [PATCH 48/50] added default crypto trait

---
 Cargo.toml                   |  6 ++----
 examples/basic_test.rs       |  2 +-
 examples/benchmark.rs        | 16 ++--------------
 src/crypto_impl/kyber1024.rs |  4 ++--
 src/crypto_impl/mod.rs       | 22 ++++++++++++++++++++++
 5 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 0078064..c7ec4f9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,10 +25,8 @@ hmac = { version = "0.12.1", default-features = false, optional = true }
 openssl-sys = { version = "0.9.91", default-features = false, optional = true }
 
 [features]
-default = ["debug", "p384", "sha2", "pqc_kyber", "openssl-sys"]
+default = ["debug", "default-crypto"]
+default-crypto = ["p384", "sha2", "pqc_kyber", "openssl-sys", "rand_core/getrandom"]
 sha2 = ["dep:sha2", "dep:hmac"]
 logging = []
 debug = ["logging"]
-
-[dev-dependencies]
-rand_core = { version = "0.6.4", features = ["getrandom"] }
diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 11e5d0b..58a8ed5 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -57,7 +57,7 @@ impl CryptoLayer for TestApplication {
     type Hmac = HmacSha512Crate;
     type PublicKey = P384CratePublicKey;
     type KeyPair = P384CrateKeyPair;
-    type Kem = RustKyber1024PrivateKey;
+    type Kem = Kyber1024CratePrivateKey;
 
     type SessionData = u128;
 
diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index 58e5534..cc30885 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -8,7 +8,7 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 
 use zssp::application::{
-    AcceptAction, ApplicationLayer, CryptoLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate,
+    AcceptAction, ApplicationLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate,
     RATCHET_SIZE,
 };
 use zssp::crypto::P384KeyPair;
@@ -53,20 +53,8 @@ impl AsRef<[u8]> for PooledVec {
 }
 
 #[allow(unused)]
-impl CryptoLayer for TestApplication {
-    type Rng = OsRng;
-    type PrpEnc = Aes256OpenSSLEnc;
-    type PrpDec = Aes256OpenSSLDec;
-    type Aead = AesGcmOpenSSL;
-    type AeadPool = AesGcmOpenSSLPool;
-    type Hash = Sha512Crate;
-    type Hmac = HmacSha512Crate;
-    type PublicKey = P384CratePublicKey;
-    type KeyPair = P384CrateKeyPair;
-    type Kem = RustKyber1024PrivateKey;
-
+impl DefaultCrypto for TestApplication {
     type SessionData = ();
-
     type IncomingPacketBuffer = PooledVec;
 }
 #[allow(unused)]
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index 4a70105..dd50978 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -5,8 +5,8 @@ use crate::crypto::*;
 
 /// A wrapper for a buffer the size of a pqc_kyber secret key.
 /// The crate `pqc_kyber` is low level and operates directly on buffers of bytes.
-pub type RustKyber1024PrivateKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
-impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for RustKyber1024PrivateKey {
+pub type Kyber1024CratePrivateKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
+impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for Kyber1024CratePrivateKey {
     fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
         // According to the source code this can only fail if the RNG fails.
         // Idk why rust allows RNG to fail.
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
index d481ff4..e08234b 100644
--- a/src/crypto_impl/mod.rs
+++ b/src/crypto_impl/mod.rs
@@ -27,3 +27,25 @@ mod openssl;
 pub use openssl::*;
 #[cfg(feature = "openssl-sys")]
 pub use openssl_sys;
+
+#[cfg(feature = "default-crypto")]
+pub trait DefaultCrypto {
+    type SessionData;
+    type IncomingPacketBuffer: AsMut<[u8]> + AsRef<[u8]>;
+}
+#[cfg(feature = "default-crypto")]
+impl<C: DefaultCrypto> crate::application::CryptoLayer for C {
+    type Rng = rand_core::OsRng;
+    type PrpEnc = Aes256OpenSSLEnc;
+    type PrpDec = Aes256OpenSSLDec;
+    type Aead = AesGcmOpenSSL;
+    type AeadPool = AesGcmOpenSSLPool;
+    type Hash = Sha512Crate;
+    type Hmac = HmacSha512Crate;
+    type PublicKey = P384CratePublicKey;
+    type KeyPair = P384CrateKeyPair;
+    type Kem = Kyber1024CratePrivateKey;
+
+    type SessionData = C::SessionData;
+    type IncomingPacketBuffer = C::IncomingPacketBuffer;
+}

From 5a9296c2cae5aaadc31d183afa98146406cd22d8 Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 16 Aug 2023 12:10:14 -0400
Subject: [PATCH 49/50] renamed crypto impls

---
 examples/basic_test.rs       | 34 ++++++++--------
 examples/benchmark.rs        | 16 ++++----
 src/crypto_impl/kyber1024.rs |  4 +-
 src/crypto_impl/mod.rs       | 18 ++++-----
 src/crypto_impl/openssl.rs   | 76 ++++++++++++++++++------------------
 src/crypto_impl/p384_impl.rs |  8 ++--
 src/crypto_impl/sha512.rs    | 10 ++---
 7 files changed, 83 insertions(+), 83 deletions(-)

diff --git a/examples/basic_test.rs b/examples/basic_test.rs
index 58a8ed5..1c5534c 100644
--- a/examples/basic_test.rs
+++ b/examples/basic_test.rs
@@ -49,15 +49,15 @@ impl CryptoLayer for TestApplication {
     };
 
     type Rng = OsRng;
-    type PrpEnc = Aes256OpenSSLEnc;
-    type PrpDec = Aes256OpenSSLDec;
-    type Aead = AesGcmOpenSSL;
-    type AeadPool = AesGcmOpenSSLPool;
-    type Hash = Sha512Crate;
-    type Hmac = HmacSha512Crate;
-    type PublicKey = P384CratePublicKey;
-    type KeyPair = P384CrateKeyPair;
-    type Kem = Kyber1024CratePrivateKey;
+    type PrpEnc = OpenSSLAes256Enc;
+    type PrpDec = OpenSSLAes256Dec;
+    type Aead = OpenSSLAesGcm;
+    type AeadPool = OpenSSLAesGcmPool;
+    type Hash = CrateSha512;
+    type Hmac = CrateHmacSha512;
+    type PublicKey = CrateP384PublicKey;
+    type KeyPair = CrateP384KeyPair;
+    type Kem = CrateKyber1024PrivateKey;
 
     type SessionData = u128;
 
@@ -81,7 +81,7 @@ impl ApplicationLayer for &TestApplication {
 
     fn check_accept_session(
         &mut self,
-        remote_static_key: &P384CratePublicKey,
+        remote_static_key: &CrateP384PublicKey,
         identity: &[u8],
     ) -> AcceptAction<TestApplication> {
         AcceptAction {
@@ -98,7 +98,7 @@ impl ApplicationLayer for &TestApplication {
 
     fn restore_by_identity(
         &mut self,
-        remote_static_key: &P384CratePublicKey,
+        remote_static_key: &CrateP384PublicKey,
         session_data: &u128,
     ) -> Result<Option<RatchetStates>, ()> {
         let ratchets = self.ratchets.lock().unwrap();
@@ -107,7 +107,7 @@ impl ApplicationLayer for &TestApplication {
 
     fn save_ratchet_state(
         &mut self,
-        remote_static_key: &P384CratePublicKey,
+        remote_static_key: &CrateP384PublicKey,
         session_data: &u128,
         update_data: RatchetUpdate<'_>,
     ) -> Result<(), ()> {
@@ -144,8 +144,8 @@ fn alice_main(
     alice_out: mpsc::SyncSender<Vec<u8>>,
     alice_in: mpsc::Receiver<Vec<u8>>,
     recursive_out: mpsc::SyncSender<Vec<u8>>,
-    alice_keypair: P384CrateKeyPair,
-    bob_pubkey: P384CratePublicKey,
+    alice_keypair: CrateP384KeyPair,
+    bob_pubkey: CrateP384PublicKey,
 ) {
     let startup_time = std::time::Instant::now();
     let context = zssp::Context::<TestApplication>::new(alice_keypair, OsRng);
@@ -251,7 +251,7 @@ fn bob_main(
     bob_out: mpsc::SyncSender<Vec<u8>>,
     bob_in: mpsc::Receiver<Vec<u8>>,
     recursive_out: mpsc::SyncSender<Vec<u8>>,
-    bob_keypair: P384CrateKeyPair,
+    bob_keypair: CrateP384KeyPair,
 ) {
     let startup_time = std::time::Instant::now();
     let context = zssp::Context::<TestApplication>::new(bob_keypair, OsRng);
@@ -335,13 +335,13 @@ fn bob_main(
 fn core(time: u64, packet_success_rate: u32) {
     let run = &AtomicBool::new(true);
 
-    let alice_keypair = P384CrateKeyPair::generate(&mut OsRng);
+    let alice_keypair = CrateP384KeyPair::generate(&mut OsRng);
     let alice_app = TestApplication {
         time: Instant::now(),
         name: "alice",
         ratchets: Mutex::new(Ratchets::new()),
     };
-    let bob_keypair = P384CrateKeyPair::generate(&mut OsRng);
+    let bob_keypair = CrateP384KeyPair::generate(&mut OsRng);
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication {
         time: Instant::now(),
diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index cc30885..30778ff 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -75,7 +75,7 @@ impl ApplicationLayer for &TestApplication {
 
     fn check_accept_session(
         &mut self,
-        remote_static_key: &P384CratePublicKey,
+        remote_static_key: &CrateP384PublicKey,
         identity: &[u8],
     ) -> AcceptAction<TestApplication> {
         AcceptAction {
@@ -91,7 +91,7 @@ impl ApplicationLayer for &TestApplication {
 
     fn restore_by_identity(
         &mut self,
-        remote_static_key: &P384CratePublicKey,
+        remote_static_key: &CrateP384PublicKey,
         session_data: &(),
     ) -> Result<Option<RatchetStates>, ()> {
         Ok(None)
@@ -99,7 +99,7 @@ impl ApplicationLayer for &TestApplication {
 
     fn save_ratchet_state(
         &mut self,
-        remote_static_key: &P384CratePublicKey,
+        remote_static_key: &CrateP384PublicKey,
         session_data: &(),
         update_data: RatchetUpdate<'_>,
     ) -> Result<(), ()> {
@@ -117,8 +117,8 @@ fn alice_main(
     alice_app: &TestApplication,
     alice_out: mpsc::SyncSender<PooledVec>,
     alice_in: mpsc::Receiver<PooledVec>,
-    alice_keypair: P384CrateKeyPair,
-    bob_pubkey: P384CratePublicKey,
+    alice_keypair: CrateP384KeyPair,
+    bob_pubkey: CrateP384PublicKey,
 ) {
     let startup_time = std::time::Instant::now();
     let context = zssp::Context::<TestApplication>::new(alice_keypair, OsRng);
@@ -211,7 +211,7 @@ fn bob_main(
     bob_app: &TestApplication,
     bob_out: mpsc::SyncSender<PooledVec>,
     bob_in: mpsc::Receiver<PooledVec>,
-    bob_keypair: P384CrateKeyPair,
+    bob_keypair: CrateP384KeyPair,
 ) {
     let startup_time = std::time::Instant::now();
     let context = zssp::Context::<TestApplication>::new(bob_keypair, OsRng);
@@ -292,9 +292,9 @@ fn bob_main(
 fn core(time: u64) {
     let run = &AtomicBool::new(true);
 
-    let alice_keypair = P384CrateKeyPair::generate(&mut OsRng);
+    let alice_keypair = CrateP384KeyPair::generate(&mut OsRng);
     let alice_app = TestApplication { time: Instant::now() };
-    let bob_keypair = P384CrateKeyPair::generate(&mut OsRng);
+    let bob_keypair = CrateP384KeyPair::generate(&mut OsRng);
     let bob_pubkey = bob_keypair.public_key();
     let bob_app = TestApplication { time: Instant::now() };
 
diff --git a/src/crypto_impl/kyber1024.rs b/src/crypto_impl/kyber1024.rs
index dd50978..ef553c2 100644
--- a/src/crypto_impl/kyber1024.rs
+++ b/src/crypto_impl/kyber1024.rs
@@ -5,8 +5,8 @@ use crate::crypto::*;
 
 /// A wrapper for a buffer the size of a pqc_kyber secret key.
 /// The crate `pqc_kyber` is low level and operates directly on buffers of bytes.
-pub type Kyber1024CratePrivateKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
-impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for Kyber1024CratePrivateKey {
+pub type CrateKyber1024PrivateKey = Zeroizing<[u8; pqc_kyber::KYBER_SECRETKEYBYTES]>;
+impl<Rng: RngCore + CryptoRng> Kyber1024PrivateKey<Rng> for CrateKyber1024PrivateKey {
     fn generate(rng: &mut Rng) -> (Self, [u8; KYBER_PUBLIC_KEY_SIZE]) {
         // According to the source code this can only fail if the RNG fails.
         // Idk why rust allows RNG to fail.
diff --git a/src/crypto_impl/mod.rs b/src/crypto_impl/mod.rs
index e08234b..8aa0ceb 100644
--- a/src/crypto_impl/mod.rs
+++ b/src/crypto_impl/mod.rs
@@ -36,15 +36,15 @@ pub trait DefaultCrypto {
 #[cfg(feature = "default-crypto")]
 impl<C: DefaultCrypto> crate::application::CryptoLayer for C {
     type Rng = rand_core::OsRng;
-    type PrpEnc = Aes256OpenSSLEnc;
-    type PrpDec = Aes256OpenSSLDec;
-    type Aead = AesGcmOpenSSL;
-    type AeadPool = AesGcmOpenSSLPool;
-    type Hash = Sha512Crate;
-    type Hmac = HmacSha512Crate;
-    type PublicKey = P384CratePublicKey;
-    type KeyPair = P384CrateKeyPair;
-    type Kem = Kyber1024CratePrivateKey;
+    type PrpEnc = OpenSSLAes256Enc;
+    type PrpDec = OpenSSLAes256Dec;
+    type Aead = OpenSSLAesGcm;
+    type AeadPool = OpenSSLAesGcmPool;
+    type Hash = CrateSha512;
+    type Hmac = CrateHmacSha512;
+    type PublicKey = CrateP384PublicKey;
+    type KeyPair = CrateP384KeyPair;
+    type Kem = CrateKyber1024PrivateKey;
 
     type SessionData = C::SessionData;
     type IncomingPacketBuffer = C::IncomingPacketBuffer;
diff --git a/src/crypto_impl/openssl.rs b/src/crypto_impl/openssl.rs
index 43125ae..8a73e92 100644
--- a/src/crypto_impl/openssl.rs
+++ b/src/crypto_impl/openssl.rs
@@ -7,18 +7,18 @@ use openssl_sys::*;
 
 use crate::crypto::*;
 
-pub struct CipherCtx(NonNull<openssl_sys::EVP_CIPHER_CTX>);
-impl Drop for CipherCtx {
+pub struct OpenSSLCtx(NonNull<openssl_sys::EVP_CIPHER_CTX>);
+impl Drop for OpenSSLCtx {
     fn drop(&mut self) {
         unsafe {
             EVP_CIPHER_CTX_free(self.0.as_ptr());
         }
     }
 }
-impl CipherCtx {
+impl OpenSSLCtx {
     /// Creates a new context.
     pub fn new() -> Option<Self> {
-        unsafe { Some(CipherCtx(NonNull::new(EVP_CIPHER_CTX_new())?)) }
+        unsafe { Some(OpenSSLCtx(NonNull::new(EVP_CIPHER_CTX_new())?)) }
     }
 
     pub unsafe fn cipher_init<const ENCRYPT: bool>(
@@ -88,13 +88,13 @@ impl CipherCtx {
     }
 }
 
-pub struct Aes256OpenSSLEnc(Mutex<CipherCtx>);
-unsafe impl Send for Aes256OpenSSLEnc {}
-unsafe impl Sync for Aes256OpenSSLEnc {}
+pub struct OpenSSLAes256Enc(Mutex<OpenSSLCtx>);
+unsafe impl Send for OpenSSLAes256Enc {}
+unsafe impl Sync for OpenSSLAes256Enc {}
 
-impl Aes256Enc for Aes256OpenSSLEnc {
+impl Aes256Enc for OpenSSLAes256Enc {
     fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self {
-        let ctx = CipherCtx::new().unwrap();
+        let ctx = OpenSSLCtx::new().unwrap();
         unsafe {
             let t = openssl_sys::EVP_aes_256_ecb();
             assert!(ctx.cipher_init::<true>(t, key.as_ptr(), ptr::null()));
@@ -118,13 +118,13 @@ impl Aes256Enc for Aes256OpenSSLEnc {
         unsafe { assert!(ctx.update::<true>(block, ptr)) }
     }
 }
-pub struct Aes256OpenSSLDec(Mutex<CipherCtx>);
-unsafe impl Send for Aes256OpenSSLDec {}
-unsafe impl Sync for Aes256OpenSSLDec {}
+pub struct OpenSSLAes256Dec(Mutex<OpenSSLCtx>);
+unsafe impl Send for OpenSSLAes256Dec {}
+unsafe impl Sync for OpenSSLAes256Dec {}
 
-impl Aes256Dec for Aes256OpenSSLDec {
+impl Aes256Dec for OpenSSLAes256Dec {
     fn new(key: &[u8; AES_256_KEY_SIZE]) -> Self {
-        let ctx = CipherCtx::new().unwrap();
+        let ctx = OpenSSLCtx::new().unwrap();
         unsafe {
             let t = openssl_sys::EVP_aes_256_ecb();
             assert!(ctx.cipher_init::<false>(t, key.as_ptr(), ptr::null()));
@@ -149,8 +149,8 @@ impl Aes256Dec for Aes256OpenSSLDec {
     }
 }
 
-pub struct AesGcmOpenSSLEnc<'a>(MutexGuard<'a, CipherCtx>);
-impl<'a> AesGcmEncContext for AesGcmOpenSSLEnc<'a> {
+pub struct OpenSSLAesGcmEnc<'a>(MutexGuard<'a, OpenSSLCtx>);
+impl<'a> AesGcmEncContext for OpenSSLAesGcmEnc<'a> {
     fn encrypt(&mut self, input: &[u8], output: &mut [u8]) {
         unsafe { assert!(self.0.update::<true>(input, output.as_mut_ptr())) };
     }
@@ -165,8 +165,8 @@ impl<'a> AesGcmEncContext for AesGcmOpenSSLEnc<'a> {
     }
 }
 
-pub struct AesGcmOpenSSLDec<'a>(MutexGuard<'a, CipherCtx>);
-impl<'a> AesGcmDecContext for AesGcmOpenSSLDec<'a> {
+pub struct OpenSSLAesGcmDec<'a>(MutexGuard<'a, OpenSSLCtx>);
+impl<'a> AesGcmDecContext for OpenSSLAesGcmDec<'a> {
     fn decrypt_in_place(&mut self, data: &mut [u8]) {
         let p = data.as_mut_ptr();
         unsafe { assert!(self.0.update::<false>(data, p)) };
@@ -177,30 +177,30 @@ impl<'a> AesGcmDecContext for AesGcmOpenSSLDec<'a> {
     }
 }
 
-pub struct AesGcmOpenSSLPool {
-    enc: [Mutex<CipherCtx>; 8],
-    dec: [Mutex<CipherCtx>; 8],
+pub struct OpenSSLAesGcmPool {
+    enc: [Mutex<OpenSSLCtx>; 8],
+    dec: [Mutex<OpenSSLCtx>; 8],
 }
-unsafe impl Send for AesGcmOpenSSLPool {}
-unsafe impl Sync for AesGcmOpenSSLPool {}
+unsafe impl Send for OpenSSLAesGcmPool {}
+unsafe impl Sync for OpenSSLAesGcmPool {}
 
-impl HighThroughputAesGcmPool for AesGcmOpenSSLPool {
-    type EncContext<'a> = AesGcmOpenSSLEnc<'a>;
+impl HighThroughputAesGcmPool for OpenSSLAesGcmPool {
+    type EncContext<'a> = OpenSSLAesGcmEnc<'a>;
 
-    type DecContext<'a> = AesGcmOpenSSLDec<'a>;
+    type DecContext<'a> = OpenSSLAesGcmDec<'a>;
 
     fn new(encrypt_key: &[u8; AES_256_KEY_SIZE], decrypt_key: &[u8; AES_256_KEY_SIZE]) -> Self {
         unsafe {
-            AesGcmOpenSSLPool {
+            OpenSSLAesGcmPool {
                 enc: std::array::from_fn(|_| {
-                    let ctx = CipherCtx::new().unwrap();
+                    let ctx = OpenSSLCtx::new().unwrap();
                     let t = openssl_sys::EVP_aes_256_gcm();
                     assert!(ctx.cipher_init::<true>(t, encrypt_key.as_ptr(), ptr::null()));
                     openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
                     Mutex::new(ctx)
                 }),
                 dec: std::array::from_fn(|_| {
-                    let ctx = CipherCtx::new().unwrap();
+                    let ctx = OpenSSLCtx::new().unwrap();
                     let t = openssl_sys::EVP_aes_256_gcm();
                     assert!(ctx.cipher_init::<false>(t, decrypt_key.as_ptr(), ptr::null()));
                     openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
@@ -210,27 +210,27 @@ impl HighThroughputAesGcmPool for AesGcmOpenSSLPool {
         }
     }
 
-    fn start_enc<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> AesGcmOpenSSLEnc {
+    fn start_enc<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> OpenSSLAesGcmEnc {
         let i = u64::from_be_bytes(nonce[4..].try_into().unwrap());
         let g = self.enc[(i as usize) % self.enc.len()].lock().unwrap();
         unsafe {
             assert!(g.cipher_init::<true>(ptr::null(), ptr::null(), nonce.as_ptr()));
         }
-        AesGcmOpenSSLEnc(g)
+        OpenSSLAesGcmEnc(g)
     }
 
-    fn start_dec<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> AesGcmOpenSSLDec {
+    fn start_dec<'a>(&'a self, nonce: &[u8; AES_GCM_NONCE_SIZE]) -> OpenSSLAesGcmDec {
         let i = u64::from_be_bytes(nonce[4..].try_into().unwrap());
         let g = self.dec[(i as usize) % self.enc.len()].lock().unwrap();
         unsafe {
             assert!(g.cipher_init::<false>(ptr::null(), ptr::null(), nonce.as_ptr()));
         }
-        AesGcmOpenSSLDec(g)
+        OpenSSLAesGcmDec(g)
     }
 }
 
-pub struct AesGcmOpenSSL;
-impl LowThroughputAesGcm for AesGcmOpenSSL {
+pub struct OpenSSLAesGcm;
+impl LowThroughputAesGcm for OpenSSLAesGcm {
     fn encrypt_in_place(
         key: &[u8; AES_256_KEY_SIZE],
         nonce: &[u8; AES_GCM_NONCE_SIZE],
@@ -238,7 +238,7 @@ impl LowThroughputAesGcm for AesGcmOpenSSL {
         data: &mut [u8],
     ) -> [u8; AES_GCM_TAG_SIZE] {
         let mut output = [0u8; AES_GCM_TAG_SIZE];
-        let ctx = CipherCtx::new().unwrap();
+        let ctx = OpenSSLCtx::new().unwrap();
         unsafe {
             let t = openssl_sys::EVP_aes_256_gcm();
             assert!(ctx.cipher_init::<true>(t, key.as_ptr(), nonce.as_ptr()));
@@ -261,7 +261,7 @@ impl LowThroughputAesGcm for AesGcmOpenSSL {
         data: &mut [u8],
         tag: &[u8; AES_GCM_TAG_SIZE],
     ) -> bool {
-        let ctx = CipherCtx::new().unwrap();
+        let ctx = OpenSSLCtx::new().unwrap();
         unsafe {
             let t = openssl_sys::EVP_aes_256_gcm();
             assert!(ctx.cipher_init::<false>(t, key.as_ptr(), nonce.as_ptr()));
@@ -282,7 +282,7 @@ mod test {
     #[test]
     fn aes_128_ecb() {
         let key = [1u8; 16];
-        let ctx = CipherCtx::new().unwrap();
+        let ctx = OpenSSLCtx::new().unwrap();
         unsafe {
             assert!(ctx.cipher_init::<true>(openssl_sys::EVP_aes_128_ecb(), key.as_ptr(), ptr::null()));
             openssl_sys::EVP_CIPHER_CTX_set_padding(ctx.as_ptr(), 0);
diff --git a/src/crypto_impl/p384_impl.rs b/src/crypto_impl/p384_impl.rs
index 77c0938..17bfb1b 100644
--- a/src/crypto_impl/p384_impl.rs
+++ b/src/crypto_impl/p384_impl.rs
@@ -3,8 +3,8 @@ use rand_core::{CryptoRng, RngCore};
 
 use crate::crypto::*;
 
-pub type P384CratePublicKey = PublicKey;
-impl P384PublicKey for P384CratePublicKey {
+pub type CrateP384PublicKey = PublicKey;
+impl P384PublicKey for CrateP384PublicKey {
     fn from_bytes(raw_key: &[u8; P384_PUBLIC_KEY_SIZE]) -> Option<Self> {
         PublicKey::from_sec1_bytes(raw_key).ok()
     }
@@ -15,8 +15,8 @@ impl P384PublicKey for P384CratePublicKey {
     }
 }
 
-pub type P384CrateKeyPair = EphemeralSecret;
-impl<Rng: RngCore + CryptoRng> P384KeyPair<Rng> for P384CrateKeyPair {
+pub type CrateP384KeyPair = EphemeralSecret;
+impl<Rng: RngCore + CryptoRng> P384KeyPair<Rng> for CrateP384KeyPair {
     type PublicKey = PublicKey;
 
     fn generate(rng: &mut Rng) -> Self {
diff --git a/src/crypto_impl/sha512.rs b/src/crypto_impl/sha512.rs
index ba932f8..1a1bd4d 100644
--- a/src/crypto_impl/sha512.rs
+++ b/src/crypto_impl/sha512.rs
@@ -3,8 +3,8 @@ use sha2::{Digest, Sha512};
 
 use crate::crypto::*;
 
-pub type Sha512Crate = Sha512;
-impl Sha512Hash for Sha512Crate {
+pub type CrateSha512 = Sha512;
+impl Sha512Hash for CrateSha512 {
     fn new() -> Self {
         Digest::new()
     }
@@ -20,10 +20,10 @@ impl Sha512Hash for Sha512Crate {
     }
 }
 
-pub struct HmacSha512Crate;
-impl Sha512Hmac for HmacSha512Crate {
+pub struct CrateHmacSha512;
+impl Sha512Hmac for CrateHmacSha512 {
     fn new() -> Self {
-        HmacSha512Crate
+        CrateHmacSha512
     }
 
     fn hash(&mut self, key: &[u8], full_input: &[u8], output: &mut [u8; SHA512_HASH_SIZE]) {

From 81d12879a4ec395e79aaf3be658d7a7b4e53e18f Mon Sep 17 00:00:00 2001
From: Monica Moniot <mamoniot@protonmail.com>
Date: Wed, 16 Aug 2023 12:38:17 -0400
Subject: [PATCH 50/50] cargo fmt

---
 examples/benchmark.rs | 5 ++---
 src/proto.rs          | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index 30778ff..c570df9 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -8,13 +8,12 @@ use rand_core::OsRng;
 use rand_core::RngCore;
 
 use zssp::application::{
-    AcceptAction, ApplicationLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate,
-    RATCHET_SIZE,
+    AcceptAction, ApplicationLayer, IncomingSessionAction, RatchetState, RatchetStates, RatchetUpdate, RATCHET_SIZE,
 };
 use zssp::crypto::P384KeyPair;
 use zssp::crypto_impl::*;
-use zssp::Session;
 use zssp::result::ReceiveError;
+use zssp::Session;
 
 const TEST_MTU: usize = 1500;
 
diff --git a/src/proto.rs b/src/proto.rs
index e5a9249..da39de7 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -88,6 +88,7 @@ pub(crate) const LABEL_HEADER_KEY: &[u8; 4] = b"ASKH";
 pub(crate) const LABEL_KEX_KEY: &[u8; 4] = b"ASKK";
 
 pub(crate) const EXPIRE_AFTER_USES: u64 = 1 << 32 - 1;
+pub(crate) const THREAD_SAFE_COUNTER_HARD_EXPIRE: u64 = u64::MAX - 1 << 16;
 /// Determines the number of counters a session will remember. If a counter arrives over
 /// this amount out of order relative to other received counters, it is likely to be
 /// rejected on the basis that the session can't remember if this counter was replayed.
@@ -101,7 +102,6 @@ pub(crate) const COUNTER_WINDOW_MAX_SKIP_AHEAD: u64 = 1 << 24;
 /// When Bob issues a challenge to Alice to mitigate DDOS, Bob will only accept Alice's
 /// response once, and then its attached counter is added to the window.
 pub(crate) const CHALLENGE_COUNTER_WINDOW_MAX_OOO: usize = 32;
-pub(crate) const THREAD_SAFE_COUNTER_HARD_EXPIRE: u64 = u64::MAX - 1 << 16;
 
 /* Packet constants */