diff --git a/scripts/nn/optim/shampoo.dml b/scripts/nn/optim/shampoo.dml
new file mode 100644
index 00000000000..e8832bdaf9a
--- /dev/null
+++ b/scripts/nn/optim/shampoo.dml
@@ -0,0 +1,499 @@
+#-------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+#-------------------------------------------------------------
+
+/*
+ * Shampoo optimizer.
+ *
+ * Implementation of the Shampoo optimizer as described in:
+ *
+ *  Gupta et al., "Shampoo: Preconditioned Stochastic Tensor Optimization"
+ *  https://arxiv.org/abs/1802.09568
+ *
+ * Shampoo is a second-order optimization method that preconditions
+ * gradients using estimates of the row- and column-wise covariance
+ * of the gradients. Compared to first-order optimizers (SGD, Adam),
+ * Shampoo can converge faster but is significantly more memory-intensive.
+ *
+ * This implementation supports:
+ *  - Full-matrix Shampoo (exact preconditioning)
+ *  - Diagonal Shampoo (memory-efficient approximation)
+ *
+ * The choice between the two modes is determined by the shape of X
+ * and the preconditioner initialization.
+ */
+
+update = function(matrix[double] X, matrix[double] dX, double lr,
+                  matrix[double] preconL, matrix[double] preconR, boolean useDiag)
+    return(matrix[double] X, matrix[double] preconL, matrix[double] preconR){
+  /*
+   * Performs one optimization step using the Shampoo update rule.
+   *
+   *
+   * Inputs:
+   *  - X: Parameter matrix to be updated (n × m)
+   *  - dX: Gradient of the loss w.r.t. X (n × m)
+   *  - lr: Learning rate.
+   *  - preconL: Left (row) preconditioner
+   *      - Full: (n × n)
+   *      - Diagonal: (n × 1)
+   *  - preconR: Right (column) preconditioner
+   *      - Full: (m × m)
+   *      - Diagonal: (1 × m)
+   *  - useDiag: Boolean flag indicating whether diagonal Shampoo is used
+   *
+   * Outputs:
+   *  - X: Updated parameter matrix (n × m)
+   *  - preconL: Updated left preconditioner
+   *      - Full: (n × n)
+   *      - Diagonal: (n × 1)
+   *  - preconR: Updated right preconditioner
+   *      - Full: (m × m)
+   *      - Diagonal: (1 × m)
+   */    
+
+  # Full-matrix Shampoo:
+  # Only used if both dimensions are small enough
+  if(useDiag==FALSE){
+
+    preconL = preconL + dX %*% t(dX)
+    preconR = preconR + t(dX) %*% dX
+
+    [LEigenvalue, LEigenvector] = eigen(preconL)
+    preconLInvPowerRoot = LEigenvector %*% diag(LEigenvalue^(-0.25)) %*% t(LEigenvector)
+
+    [REigenvalue, REigenvector] = eigen(preconR)
+    preconRInvPowerRoot = REigenvector %*% diag(REigenvalue^(-0.25)) %*% t(REigenvector)
+
+    X = X - lr * preconLInvPowerRoot %*% dX %*% preconRInvPowerRoot
+  
+  # Diagonal Shampoo:
+  # Memory-efficient approximation for large parameter matrices
+  } else{
+    n = nrow(dX)
+    m = ncol(dX)
+
+    preconL = preconL + rowSums(dX^2)          
+    preconR = preconR + colSums(dX^2)  
+
+    preconLScale = preconL^(-0.25)        
+    preconRScale = preconR^(-0.25)
+
+    preconLMatrix = preconLScale %*% matrix(1, rows=1, cols=m)
+    preconRMatrix = matrix(1, rows=n, cols=1) %*% preconRScale
+
+    scaledGrad = dX * preconLMatrix;
+    scaledGrad = scaledGrad * preconRMatrix;
+
+    X = X - lr * scaledGrad;
+
+  }
+}
+
+init = function(matrix[double] X, double epsilon, int useDiagThreshold)
+    return (matrix[double] preconL, matrix[double] preconR, boolean useDiag) {
+  /*
+   * Initializes the Shampoo preconditioners for a given parameter matrix.
+   *
+   * Depending on the size of X, this function initializes either:
+   *  - Full identity matrices (exact Shampoo), or
+   *  - Diagonal vectors (approximate Shampoo)
+   *
+   * This threshold is crucial to avoid excessive memory usage,
+   * as full Shampoo requires O(n^2 + m^2) memory per parameter matrix.
+   *
+   * Inputs:
+   *  - X: Parameter matrix to be optimized (n, m)
+   *  - epsilon: Numerical stability constant
+   *  - useDiagThreshold: Dimension threshold above which diagonal
+   *                      preconditioning is used
+   *
+   * Outputs:
+   *  - preconL: Initial left preconditioner
+   *      - Full: (n × n) identity scaled by epsilon
+   *      - Diagonal: (n × 1) filled with epsilon
+   *  - preconR: Initial right preconditioner
+   *      - Full: (m × m) identity scaled by epsilon
+   *      - Diagonal: (1 × m) filled with epsilon
+   *  - useDiag: Boolean flag indicating whether diagonal Shampoo is used
+   */
+
+  # Use diagonal Shampoo if parameter matrix is too large
+  if((nrow(X) > useDiagThreshold) | (ncol(X) > useDiagThreshold)){
+    preconL = matrix(epsilon, rows=nrow(X), cols=1);
+    preconR = matrix(epsilon, rows=1, cols=ncol(X));
+    useDiag = TRUE
+
+  # Use full Shampoo if parameter matrix is small enough
+  } else {
+    preconL = matrix(0, rows=nrow(X), cols=nrow(X));
+    index = 1;
+      while (index <= nrow(X)){
+          preconL[index, index] = epsilon * 1
+          index = index + 1
+      }
+    preconR = matrix(0, rows=ncol(X), cols=ncol(X));
+    index = 1;
+      while (index <= ncol(X)){
+          preconR[index, index] = epsilon * 1
+          index = index + 1
+      }
+    useDiag = FALSE
+  }
+}
+
+update_momentum = function(matrix[double] X, matrix[double] dX, double lr,
+                  matrix[double] preconL, matrix[double] preconR, 
+                  matrix[double] momentum, boolean useDiag)
+    return(matrix[double] X, matrix[double] preconL, matrix[double] preconR, 
+           matrix[double] momentum){
+  /*
+   * Performs one optimization step using the Shampoo update rule, while using momentum.
+   *
+   *
+   * Inputs:
+   *  - X: Parameter matrix to be updated (n × m)
+   *  - dX: Gradient of the loss w.r.t. X (n × m)
+   *  - lr: Learning rate.
+   *  - preconL: Left (row) preconditioner
+   *               - Full: (n × n)
+   *               - Diagonal: (n × 1)
+   *  - preconR: Right (column) preconditioner
+   *               - Full: (m × m)
+   *               - Diagonal: (1 × m)
+   *  - momentum: momentum (n × m)
+   *  - useDiag: Boolean flag indicating whether diagonal Shampoo is used
+   *
+   * Outputs:
+   *  - X: Updated parameter matrix (n × m)
+   *  - preconL: Updated left preconditioner
+   *      - Full: (n × n)
+   *      - Diagonal: (n × 1)
+   *  - preconR: Updated right preconditioner
+   *      - Full: (m × m)
+   *      - Diagonal: (1 × m)
+   *  - momentum: Updated momentum (n × m)
+   */    
+
+  # calculating the updated momentum
+  momentum = 0.9 * momentum + (0.1)*dX
+
+  # Full-matrix Shampoo:
+  # Only used if both dimensions are small enough
+  if(useDiag==FALSE){
+
+    preconL = preconL + dX %*% t(dX)
+    preconR = preconR + t(dX) %*% dX
+
+    [LEigenvalue, LEigenvector] = eigen(preconL)
+    preconLInvPowerRoot = LEigenvector %*% diag(LEigenvalue^(-0.25)) %*% t(LEigenvector)
+
+    [REigenvalue, REigenvector] = eigen(preconR)
+    preconRInvPowerRoot = REigenvector %*% diag(REigenvalue^(-0.25)) %*% t(REigenvector)
+
+    X = X - lr * preconLInvPowerRoot %*% momentum %*% preconRInvPowerRoot
+  
+  # Diagonal Shampoo:
+  # Memory-efficient approximation for large parameter matrices
+  } else{
+      n = nrow(dX)
+      m = ncol(dX)
+
+      preconL = preconL + rowSums(dX ^ 2)
+      preconR = preconR + colSums(dX ^ 2)
+
+      preconLScale = preconL^(-0.25)        
+      preconRScale = preconR^(-0.25)
+
+      preconLMatrix = preconLScale %*% matrix(1, rows=1, cols=m)
+      preconRMatrix = matrix(1, rows=n, cols=1) %*% preconRScale
+
+      scaledGrad = momentum * preconLMatrix
+      scaledGrad = scaledGrad * preconRMatrix
+
+      X = X - lr * scaledGrad         
+    }
+}
+
+init_momentum = function(matrix[double] X, double epsilon, int useDiagThreshold)
+    return (matrix[double] preconL, matrix[double] preconR, 
+            matrix[double] momentum, boolean useDiag) {
+  /*
+   * Initializes the Shampoo preconditioners and momentum for a given parameter matrix.
+   *
+   * Depending on the size of X, this function initializes either:
+   *  - Full identity matrices (exact Shampoo), or
+   *  - Diagonal vectors (approximate Shampoo)
+   *
+   * This threshold is crucial to avoid excessive memory usage,
+   * as full Shampoo requires O(n² + m²) memory per parameter matrix.
+   *
+   * Inputs:
+   *  - X: Parameter matrix to be optimized (n, m)
+   *  - epsilon: Numerical stability constant
+   *  - useDiagThreshold: Dimension threshold above which diagonal
+   *                      preconditioning is used
+   *
+   * Outputs:
+   *  - preconL: Initial left preconditioner
+   *      - Full: (n × n) identity scaled by epsilon
+   *      - Diagonal: (n × 1) filled with epsilon
+   *  - preconR: Initial right preconditioner
+   *      - Full: (m × m) identity scaled by epsilon
+   *      - Diagonal: (1 × m) filled with epsilon
+   *  - momentum: Initial momentum (n × m), initialized to zeros
+   *  - useDiag: Boolean flag indicating whether diagonal Shampoo is used
+   */
+
+  # Use diagonal Shampoo if parameter matrix is too large
+  if((nrow(X) > useDiagThreshold) | (ncol(X) > useDiagThreshold)){
+    preconL = matrix(epsilon, rows=nrow(X), cols=1);
+    preconR = matrix(epsilon, rows=1, cols=ncol(X));
+    useDiag = TRUE
+
+  # Use full Shampoo if parameter matrix is small enough
+  } else {
+    preconL = matrix(0, rows=nrow(X), cols=nrow(X));
+    index = 1;
+      while (index <= nrow(X)){
+          preconL[index, index] = epsilon * 1
+          index = index + 1
+      }
+    preconR = matrix(0, rows=ncol(X), cols=ncol(X));
+    index = 1;
+      while (index <= ncol(X)){
+          preconR[index, index] = epsilon * 1
+          index = index + 1
+      }
+    useDiag = FALSE
+  }
+  momentum = X * 0
+}
+
+update_heuristic = function(matrix[double] X, matrix[double] dX, double lr,
+                  matrix[double] preconL, matrix[double] preconR, matrix[double] momentum, 
+                  int stepCounter, int rootEvery, int preconEvery, matrix[double] bufferL, 
+                  matrix[double] bufferR, matrix[double] preconLInvPowerRoot, 
+                  matrix[double] preconRInvPowerRoot, boolean useDiag)
+    return (matrix[double] X, matrix[double] preconL, matrix[double] preconR, 
+            matrix[double] momentum, int stepCounter, matrix[double] bufferL, 
+            matrix[double] bufferR, matrix[double] preconLInvPowerRoot, 
+            matrix[double] preconRInvPowerRoot){
+  /*
+   * Performs one optimization step using the Shampoo update rule, while using momentum 
+   * and a heuristic for runtime improvements.
+   *
+   *
+   * Inputs:
+   *  - X: Parameter matrix to be updated (n × m)
+   *  - dX: Gradient of the loss w.r.t. X (n × m)
+   *  - lr: Learning rate.
+   *  - preconL: Left (row) preconditioner
+   *      - Full: (n × n)
+   *      - Diagonal: (n × 1)
+   *  - preconR: Right (column) preconditioner
+   *      - Full: (m × m)
+   *      - Diagonal: (1 × m)
+   *  - momentum: momentum (n × m)
+   *  - stepCounter: Step counter (int), incremented each call
+   *  - rootEvery: Frequency for recomputing inverse roots (int)
+   *  - preconEvery: Frequency for applying buffered updates to preconditioners (int)
+   *  - bufferL: Buffer accumulating left curvature updates
+   *      - Full: (n × n)
+   *      - Diagonal: (n × 1)
+   *  - bufferR: Buffer accumulating right curvature updates
+   *      - Full: (m × m)
+   *      - Diagonal: (1 × m)
+   *  - preconLInvPowerRoot: Cached preconL^{-1/4}
+   *      - Full: (n × n)
+   *      - Diagonal: (n × 1)
+   *  - preconRInvPowerRoot: Cached preconR^{-1/4}
+   *      - Full: (m × m)
+   *      - Diagonal: (1 × m)
+   *  - useDiag: Boolean flag indicating whether diagonal Shampoo is used
+   *
+   * Outputs:
+   *  - X: Updated parameter matrix (n × m)
+   *  - preconL: Updated left preconditioner 
+   *      - Full: (n × n)
+   *      - Diagonal: (n × 1)
+   *  - preconR: Updated right preconditioner
+   *      - Full: (m × m)
+   *      - Diagonal: (1 × m)
+   *  - momentum: momentum (n × m)
+   *  - stepCounter: Updated step counter (int)
+   *  - bufferL: Updated bufferL (reset to 0 when applied)
+   *      - Full: (n × n)
+   *      - Diagonal: (n × 1)
+   *  - bufferR: Updated bufferR (reset to 0 when applied)
+   *      - Full: (m × m)
+   *      - Diagonal: (1 × m)
+   *  - preconLInvPowerRoot: Updated cached inverse root (when recomputed)
+   *      - Full: (n × n)
+   *      - Diagonal: (n × 1)
+   *  - preconRInvPowerRoot: Updated cached inverse root (when recomputed)
+   *      - Full: (m × m)
+   *      - Diagonal: (1 × m)
+   */    
+
+  # calculating the updated momentum
+  momentum = 0.9 * momentum + (0.1)*dX
+
+  # Full-matrix Shampoo:
+  # Only used if both dimensions are small enough
+  if(useDiag==FALSE){
+    bufferL = bufferL + (dX %*% t(dX))
+    bufferR = bufferR + (t(dX) %*% dX)
+
+    if ((stepCounter > 0) & (stepCounter %% preconEvery == 0)){
+      preconL = preconL + bufferL
+      preconR = preconR + bufferR
+      bufferL = bufferL * 0
+      bufferR = bufferR * 0
+    }
+
+
+    if ((stepCounter > 0) & (stepCounter %% rootEvery == 0)){
+      [LEigenvalue, LEigenvector] = eigen(preconL)
+      preconLInvPowerRoot = LEigenvector %*% diag(LEigenvalue^(-0.25)) %*% t(LEigenvector)
+
+      [REigenvalue, REigenvector] = eigen(preconR)
+      preconRInvPowerRoot = REigenvector %*% diag(REigenvalue^(-0.25)) %*% t(REigenvector)
+    }
+
+    X = X - lr * preconLInvPowerRoot %*% momentum %*% preconRInvPowerRoot
+
+    stepCounter = stepCounter + 1
+  
+  # Diagonal Shampoo:
+  # Memory-efficient approximation for large parameter matrices
+  } else{
+    n = nrow(dX)
+    m = ncol(dX)
+
+    bufferL = bufferL + rowSums(dX ^ 2)
+    bufferR = bufferR + colSums(dX ^ 2)
+
+    if ((stepCounter > 0) & (stepCounter %% preconEvery == 0)){
+      preconL = preconL + bufferL
+      preconR = preconR + bufferR
+      bufferL = bufferL * 0
+      bufferR = bufferR * 0
+    }
+
+    if ((stepCounter > 0) & (stepCounter %% rootEvery == 0)){
+      preconLInvPowerRoot = (preconL^(-0.25))
+      preconRInvPowerRoot = (preconR^(-0.25))
+    }
+    preconLMatrix = preconLInvPowerRoot %*% matrix(1, rows=1, cols=m)
+    preconRMatrix = matrix(1, rows=n, cols=1) %*% preconRInvPowerRoot
+
+    scaledGrad = momentum * preconLMatrix
+    scaledGrad = scaledGrad * preconRMatrix
+
+    X = X - lr * scaledGrad
+    stepCounter = stepCounter + 1
+  }
+}
+
+
+
+init_heuristic = function(matrix[double] X, double epsilon, int useDiagThreshold)
+    return (matrix[double] preconL, matrix[double] preconR, int stepCounter, 
+            matrix[double] bufferL, matrix[double] bufferR, matrix[double] momentum, 
+            matrix[double] preconLInvPowerRoot, matrix[double] preconRInvPowerRoot, 
+            boolean useDiag) {
+  /*
+   * Initializes Shampoo preconditioners, buffers, cached inverse roots, 
+   * and momentum for the heuristic variant.
+   *
+   * Depending on the size of X, this function initializes either:
+   *  - Full identity matrices (exact Shampoo), or
+   *  - Diagonal vectors (approximate Shampoo)
+   *
+   * This threshold is crucial to avoid excessive memory usage,
+   * as full Shampoo requires O(n^2 + m^2) memory per parameter matrix.
+   *
+   * Inputs:
+   *  - X: Parameter matrix to be optimized (n, m)
+   *  - epsilon: Numerical stability constant
+   *  - useDiagThreshold: Dimension threshold above which diagonal
+   *                      preconditioning is used
+   *
+   * Outputs:
+   *  - preconL: Initial left preconditioner (n × n) or (n × 1)
+   *  - preconR: Initial right preconditioner (m × m) or (1 × m)
+   *  - stepCounter: Initialized to 0
+   *  - bufferL: Initialized to zeros, same shape as preconL
+   *  - bufferR: Initialized to zeros, same shape as preconR
+   *  - momentum: Initialized to zeros, same shape as X (n × m)
+   *  - preconLInvPowerRoot: Cached inverse fourth root of preconL
+   *      - Full: initialized to epsilon^{-1/4} * I (n × n)
+   *      - Diagonal: initialized to preconL^{-1/4} (n × 1)
+   *  - preconRInvPowerRoot: Cached inverse fourth root of preconR
+   *      - Full: initialized to epsilon^{-1/4} * I (m × m)
+   *      - Diagonal: initialized to preconR^{-1/4} (1 × m)
+   *  - useDiag: Boolean flag indicating whether diagonal Shampoo is used
+   */
+
+  # Use diagonal Shampoo if parameter matrix is too large
+  if((nrow(X) > useDiagThreshold) | (ncol(X) > useDiagThreshold)){
+    preconL = matrix(epsilon, rows=nrow(X), cols=1);
+    preconR = matrix(epsilon, rows=1, cols=ncol(X));
+    preconLInvPowerRoot = preconL^(-0.25)
+    preconRInvPowerRoot = preconR^(-0.25)
+    useDiag = TRUE
+
+  # Use full Shampoo if parameter matrix is small enough
+  } else {
+    preconL = matrix(0, rows=nrow(X), cols=nrow(X));
+    index = 1;
+      while (index <= nrow(X)){
+          preconL[index, index] = epsilon * 1
+          index = index + 1
+      }
+    preconR = matrix(0, rows=ncol(X), cols=ncol(X));
+    index = 1;
+      while (index <= ncol(X)){
+          preconR[index, index] = epsilon * 1
+          index = index + 1
+      }
+
+    preconLInvPowerRoot = preconL
+    i = 1
+    while(i <= nrow(preconLInvPowerRoot)) {
+      preconLInvPowerRoot[i,i] = epsilon^(-0.25)
+      i = i + 1
+    }
+
+    preconRInvPowerRoot = preconR
+    j = 1
+    while(j <= nrow(preconRInvPowerRoot)) {
+      preconRInvPowerRoot[j,j] = epsilon^(-0.25)
+      j = j + 1
+    }  
+
+    useDiag = FALSE
+  }
+  bufferR = preconR * 0
+  bufferL = preconL * 0
+  stepCounter = 0
+  momentum = X * 0
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/cifar_creation.py b/scripts/staging/shampoo_optimizer/cifar_creation.py
new file mode 100644
index 00000000000..9635381bebf
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/cifar_creation.py
@@ -0,0 +1,83 @@
+#-------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+#-------------------------------------------------------------
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+import pandas as pd
+import numpy as np
+import os
+import os.path
+
+# check if data already is downloaded
+os.makedirs("scripts/staging/shampoo_optimizer/data", exist_ok=True)
+data_exists = os.path.exists("scripts/staging/shampoo_optimizer/data/cifar-10-python.tar.gz")
+data_exists = not data_exists
+
+# get data 
+base = transforms.ToTensor()
+train_raw = datasets.CIFAR10(root="scripts/staging/shampoo_optimizer/data", train=True, download=data_exists, transform=base)
+raw_loader = DataLoader(train_raw, batch_size=512, shuffle=False, num_workers=0)
+
+# Mean/Std for each channel
+n = 0
+channel_sum = torch.zeros(3)
+channel_sum_sq = torch.zeros(3)
+
+for x, _ in raw_loader:
+    # x: [B,3,32,32] in [0,1]
+    b = x.size(0)
+    x = x.view(b, 3, -1)  # [B,3,1024]
+    channel_sum += x.mean(dim=2).sum(dim=0)
+    channel_sum_sq += (x ** 2).view(b, 3, -1).mean(dim=2).sum(dim=0)
+    n += b
+
+mean = (channel_sum / n).tolist()
+std = ((channel_sum_sq / n - torch.tensor(mean) ** 2).sqrt()).tolist()
+
+# 1. Original (only normalisation)
+transform_base = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+])
+
+# 2. Augmentation (Flip + Crop)
+transform_aug = transforms.Compose([
+    transforms.RandomCrop(32, padding=4),
+    transforms.RandomHorizontalFlip(p=1.0),
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+])
+
+train_base = datasets.CIFAR10(root="scripts/staging/shampoo_optimizer/data", train=True, download=False, transform=transform_base)
+train_aug  = datasets.CIFAR10(root="scripts/staging/shampoo_optimizer/data", train=True, download=False, transform=transform_aug)
+full_dataset = torch.utils.data.ConcatDataset([train_base, train_aug])
+loader = DataLoader(full_dataset, batch_size=128, shuffle=True, num_workers=0)
+
+data = []
+for x_batch, y_batch in loader:
+    x_batch_reshaped = torch.reshape(x_batch, (x_batch.shape[0], -1))
+    batch_reshaped = torch.cat((y_batch.unsqueeze(1), x_batch_reshaped), dim=1)
+    data.append(batch_reshaped)
+
+data = torch.vstack(data).cpu().numpy()
+df = pd.DataFrame(data)
+df[0] = df[0].astype("Int16")
+df.to_csv("scripts/staging/shampoo_optimizer/cifar10.csv",index=False, header=False)
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/diagrams/convergence_times_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_cifar.png
new file mode 100644
index 00000000000..6d3c3ca7024
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/convergence_times_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_mnist.png
new file mode 100644
index 00000000000..613361f9ac9
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_cifar.png
new file mode 100644
index 00000000000..26098e20646
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_heuristic_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_heuristic_cifar.png
new file mode 100644
index 00000000000..9531fb2fc0c
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_heuristic_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_heuristic_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_heuristic_mnist.png
new file mode 100644
index 00000000000..9312b32d65d
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_heuristic_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_mnist.png
new file mode 100644
index 00000000000..13784252f77
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_momentum_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_momentum_cifar.png
new file mode 100644
index 00000000000..670a6050c75
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_momentum_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_momentum_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_momentum_mnist.png
new file mode 100644
index 00000000000..2c9e35d7bbd
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/convergence_times_shampoo_momentum_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/diagram_metrics_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/diagram_metrics_cifar.png
new file mode 100644
index 00000000000..42d43385681
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/diagram_metrics_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/diagram_metrics_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/diagram_metrics_mnist.png
new file mode 100644
index 00000000000..789ad82b51a
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/diagram_metrics_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/run_times_shampoo_total_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/run_times_shampoo_total_cifar.png
new file mode 100644
index 00000000000..e136ddb25f0
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/run_times_shampoo_total_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/run_times_shampoo_total_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/run_times_shampoo_total_mnist.png
new file mode 100644
index 00000000000..4831671e286
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/run_times_shampoo_total_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/shampoo_diagonal_nondiagonal_comparison_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/shampoo_diagonal_nondiagonal_comparison_cifar.png
new file mode 100644
index 00000000000..2692831f4b8
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/shampoo_diagonal_nondiagonal_comparison_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/shampoo_diagonal_nondiagonal_comparison_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/shampoo_diagonal_nondiagonal_comparison_mnist.png
new file mode 100644
index 00000000000..498231beb37
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/shampoo_diagonal_nondiagonal_comparison_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/shampoo_heuristic_diagonal_nondiagonal_comparison_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/shampoo_heuristic_diagonal_nondiagonal_comparison_cifar.png
new file mode 100644
index 00000000000..503ab5fa2f4
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/shampoo_heuristic_diagonal_nondiagonal_comparison_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/shampoo_heuristic_diagonal_nondiagonal_comparison_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/shampoo_heuristic_diagonal_nondiagonal_comparison_mnist.png
new file mode 100644
index 00000000000..a1d0c79cfaa
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/shampoo_heuristic_diagonal_nondiagonal_comparison_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/shampoo_implementations_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/shampoo_implementations_cifar.png
new file mode 100644
index 00000000000..14a324b90fe
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/shampoo_implementations_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/shampoo_implementations_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/shampoo_implementations_mnist.png
new file mode 100644
index 00000000000..af20eb561e1
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/shampoo_implementations_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/shampoo_momentum_diagonal_nondiagonal_comparison_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/shampoo_momentum_diagonal_nondiagonal_comparison_cifar.png
new file mode 100644
index 00000000000..559a24f51e0
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/shampoo_momentum_diagonal_nondiagonal_comparison_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/shampoo_momentum_diagonal_nondiagonal_comparison_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/shampoo_momentum_diagonal_nondiagonal_comparison_mnist.png
new file mode 100644
index 00000000000..589ebf8db54
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/shampoo_momentum_diagonal_nondiagonal_comparison_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/total_comparison_cifar.png b/scripts/staging/shampoo_optimizer/diagrams/total_comparison_cifar.png
new file mode 100644
index 00000000000..007ccb53929
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/total_comparison_cifar.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/total_comparison_mnist.png b/scripts/staging/shampoo_optimizer/diagrams/total_comparison_mnist.png
new file mode 100644
index 00000000000..d0df77f82e9
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/total_comparison_mnist.png differ
diff --git a/scripts/staging/shampoo_optimizer/diagrams/update_step_times_single_bar.png b/scripts/staging/shampoo_optimizer/diagrams/update_step_times_single_bar.png
new file mode 100644
index 00000000000..678fdf95705
Binary files /dev/null and b/scripts/staging/shampoo_optimizer/diagrams/update_step_times_single_bar.png differ
diff --git a/scripts/staging/shampoo_optimizer/experiment_results.ipynb b/scripts/staging/shampoo_optimizer/experiment_results.ipynb
new file mode 100644
index 00000000000..82e813777a8
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/experiment_results.ipynb
@@ -0,0 +1,1265 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "93259be8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#-------------------------------------------------------------\n",
+    "#\n",
+    "# Licensed to the Apache Software Foundation (ASF) under one\n",
+    "# or more contributor license agreements.  See the NOTICE file\n",
+    "# distributed with this work for additional information\n",
+    "# regarding copyright ownership.  The ASF licenses this file\n",
+    "# to you under the Apache License, Version 2.0 (the\n",
+    "# \"License\"); you may not use this file except in compliance\n",
+    "# with the License.  You may obtain a copy of the License at\n",
+    "#\n",
+    "#   http://www.apache.org/licenses/LICENSE-2.0\n",
+    "#\n",
+    "# Unless required by applicable law or agreed to in writing,\n",
+    "# software distributed under the License is distributed on an\n",
+    "# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n",
+    "# KIND, either express or implied.  See the License for the\n",
+    "# specific language governing permissions and limitations\n",
+    "# under the License.\n",
+    "#\n",
+    "#-------------------------------------------------------------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "804d532c",
+   "metadata": {},
+   "source": [
+    "## Base functions for showing results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d9b8b2c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "def create_diagram(optimizers: list, dataset: str, save_figure: bool, title: str, save_path: str):\n",
+    "    \"\"\"\n",
+    "    Loads per-epoch metrics for multiple optimizers and plots validation loss vs. epochs.\n",
+    "\n",
+    "    Reads `metrics/metrics_{optimizer}_{dataset}.csv` for each optimizer, expecting columns:\n",
+    "    [epochs, train_losses, train_accuracies, val_losses, val_accuracies, time_for_epoch].\n",
+    "    Aggregates all runs into one DataFrame, plots one line per optimizer, and optionally\n",
+    "    saves the figure as a PNG.\n",
+    "\n",
+    "    Args:\n",
+    "        optimizers: List of optimizer names to compare (used in the metrics file names).\n",
+    "        dataset: Dataset identifier used in the metrics file names (e.g., \"mnist\", \"cifar\").\n",
+    "        save_figure: If True, saves the plot to `save_path`.\n",
+    "        title: Plot title.\n",
+    "        save_path: Output path for the PNG (only used if `save_figure` is True).\n",
+    "    \"\"\"\n",
+    "    collected_data = pd.DataFrame(columns=[\"epochs\", \"train_losses\", \"train_accuracies\", \"val_losses\", \"val_accuracies\", \"optimizer\"])\n",
+    "\n",
+    "    for optimizer in optimizers:\n",
+    "        path = f\"metrics/metrics_{optimizer}_{dataset}.csv\"\n",
+    "        df = pd.read_csv(path, names=[\"epochs\", \"train_losses\", \"train_accuracies\", \"val_losses\", \"val_accuracies\", \"time_for_epoch\"])\n",
+    "        df[\"optimizer\"] = optimizer\n",
+    "        collected_data = pd.concat([collected_data, df], axis=0)\n",
+    "\n",
+    "    figure = plt.figure(figsize=(8,8))\n",
+    "    for optimizer in optimizers:\n",
+    "        optimzer_data = collected_data[collected_data[\"optimizer\"]==optimizer]\n",
+    "        plt.plot(optimzer_data[\"epochs\"], optimzer_data[\"val_losses\"], label = optimizer)\n",
+    "\n",
+    "    plt.title(title)\n",
+    "    plt.xlabel(\"epochs\")\n",
+    "    plt.ylabel(\"validation loss\")\n",
+    "    plt.legend()\n",
+    "    if save_figure:\n",
+    "        figure.savefig(save_path, format=\"png\")\n",
+    "    plt.show()\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a4008643",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "def create_diagram_convergence(optimizers: list, dataset: str, save_figure: bool, title: str, save_path: str):\n",
+    "    \"\"\"\n",
+    "    Computes and visualizes convergence time per optimizer based on validation loss.\n",
+    "\n",
+    "    For each optimizer, this function loads `metrics/metrics_{optimizer}_{dataset}.csv`\n",
+    "    with columns:\n",
+    "    [epochs, train_losses, train_accuracies, val_losses, val_accuracies, time_for_epoch].\n",
+    "\n",
+    "    Convergence is defined as the epoch where `val_losses` reaches its minimum.\n",
+    "    The convergence time is the cumulative sum of `time_for_epoch` from epoch 1 up to\n",
+    "    (and including) that best epoch. Results are sorted by convergence time (fastest first)\n",
+    "    and plotted as a bar chart with one distinct color per optimizer and a seconds label\n",
+    "    above each bar.\n",
+    "\n",
+    "    Args:\n",
+    "        optimizers: List of optimizer names to compare (used in the metrics file names).\n",
+    "        dataset: Dataset identifier used in the metrics file names (e.g., \"mnist\", \"cifar\").\n",
+    "        save_figure: If True, saves the plot to `save_path`.\n",
+    "        title: Plot title.\n",
+    "        save_path: Output path for the PNG (only used if `save_figure` is True).\n",
+    "    \"\"\"\n",
+    "    collected_data = pd.DataFrame(columns=[\"epochs\", \"train_losses\", \"train_accuracies\", \"val_losses\", \"val_accuracies\", \"optimizer\"])\n",
+    "\n",
+    "    for optimizer in optimizers:\n",
+    "        path = f\"metrics/metrics_{optimizer}_{dataset}.csv\"\n",
+    "        df = pd.read_csv(path, names=[\"epochs\", \"train_losses\", \"train_accuracies\", \"val_losses\", \"val_accuracies\", \"time_for_epoch\"])\n",
+    "        df[\"optimizer\"] = optimizer\n",
+    "        collected_data = pd.concat([collected_data, df], axis=0)\n",
+    "\n",
+    "    figure = plt.figure(figsize=(15,8))\n",
+    "\n",
+    "    times = []\n",
+    "    epochs_to_converge = []\n",
+    "\n",
+    "    for optimizer in optimizers:\n",
+    "        optimzer_data = collected_data[collected_data[\"optimizer\"] == optimizer].copy()\n",
+    "        optimzer_data = optimzer_data.sort_values(\"epochs\")\n",
+    "\n",
+    "        idx = optimzer_data[\"val_losses\"].astype(float).idxmin()\n",
+    "        epoch_to_converge = float(optimzer_data.loc[idx, \"epochs\"])\n",
+    "        time_until_convergence = float(optimzer_data.loc[optimzer_data[\"epochs\"] <= epoch_to_converge, \"time_for_epoch\"].sum())\n",
+    "\n",
+    "        times.append(time_until_convergence)\n",
+    "        epochs_to_converge.append(epoch_to_converge)\n",
+    "\n",
+    "    # sort by convergence time\n",
+    "    sorted_idx = np.argsort(times)\n",
+    "    optimizers = [optimizers[i] for i in sorted_idx]\n",
+    "    times = [times[i] for i in sorted_idx]\n",
+    "    epochs_to_converge = [epochs_to_converge[i] for i in sorted_idx]\n",
+    "\n",
+    "    # one color per optimizer\n",
+    "    cmap = plt.get_cmap(\"tab10\")\n",
+    "    colors = [cmap(i % 10) for i in range(len(optimizers))]\n",
+    "\n",
+    "    bars = plt.bar(optimizers, times, color=colors)\n",
+    "    plt.title(title)\n",
+    "    plt.xlabel(\"optimizer\")\n",
+    "    plt.ylabel(\"time until best val loss (sec)\")\n",
+    "    plt.xticks(rotation=25, ha=\"right\")\n",
+    "\n",
+    "    for bar, t, e in zip(bars, times, epochs_to_converge):\n",
+    "        plt.text(\n",
+    "            bar.get_x() + bar.get_width() / 2,\n",
+    "            bar.get_height(),\n",
+    "            f\"{t:.2f}s\",\n",
+    "            ha=\"center\",\n",
+    "            va=\"bottom\",\n",
+    "            fontsize=10\n",
+    "        )\n",
+    "\n",
+    "\n",
+    "    if save_figure:\n",
+    "        figure.savefig(save_path, format=\"png\")\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "185e4aa9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_diagram_total_runtime(optimizers: list, dataset: str, save_figure: bool, title: str, save_path: str):\n",
+    "    \"\"\"\n",
+    "    Computes and visualizes total training runtime per optimizer across all epochs.\n",
+    "\n",
+    "    For each optimizer, this function loads `metrics/metrics_{optimizer}_{dataset}.csv`\n",
+    "    with columns:\n",
+    "    [epochs, train_losses, train_accuracies, val_losses, val_accuracies, time_for_epoch].\n",
+    "\n",
+    "    The total runtime is defined as the sum of `time_for_epoch` over all recorded epochs.\n",
+    "    Results are sorted by total runtime (fastest first) and plotted as a bar chart with\n",
+    "    one distinct color per optimizer and a seconds label above each bar.\n",
+    "\n",
+    "    Args:\n",
+    "        optimizers: List of optimizer names to compare (used in the metrics file names).\n",
+    "        dataset: Dataset identifier used in the metrics file names (e.g., \"mnist\", \"cifar\").\n",
+    "        save_figure: If True, saves the plot to `save_path`.\n",
+    "        title: Plot title.\n",
+    "        save_path: Output path for the PNG (only used if `save_figure` is True).\n",
+    "    \"\"\"\n",
+    "    collected_data = pd.DataFrame(columns=[\"epochs\", \"train_losses\", \"train_accuracies\", \"val_losses\", \"val_accuracies\", \"optimizer\"])\n",
+    "\n",
+    "    for optimizer in optimizers:\n",
+    "        path = f\"metrics/metrics_{optimizer}_{dataset}.csv\"\n",
+    "        df = pd.read_csv(path, names=[\"epochs\", \"train_losses\", \"train_accuracies\", \"val_losses\", \"val_accuracies\", \"time_for_epoch\"])\n",
+    "        df[\"optimizer\"] = optimizer\n",
+    "        collected_data = pd.concat([collected_data, df], axis=0)\n",
+    "\n",
+    "    figure = plt.figure(figsize=(15,8))\n",
+    "\n",
+    "    runtimes = []\n",
+    "    epochs_total = []\n",
+    "\n",
+    "    for optimizer in optimizers:\n",
+    "        optimzer_data = collected_data[collected_data[\"optimizer\"] == optimizer].copy()\n",
+    "        optimzer_data = optimzer_data.sort_values(\"epochs\")\n",
+    "\n",
+    "        runtime = float(optimzer_data[\"time_for_epoch\"].astype(float).sum())\n",
+    "        runtimes.append(runtime)\n",
+    "\n",
+    "        epochs_total.append(int(optimzer_data[\"epochs\"].max()))\n",
+    "\n",
+    "    # sort by total runtime (ascending)\n",
+    "    sorted_idx = np.argsort(runtimes)\n",
+    "    optimizers = [optimizers[i] for i in sorted_idx]\n",
+    "    runtimes = [runtimes[i] for i in sorted_idx]\n",
+    "    epochs_total = [epochs_total[i] for i in sorted_idx]\n",
+    "\n",
+    "    # colors\n",
+    "    cmap = plt.get_cmap(\"tab10\")\n",
+    "    colors = [cmap(i % 10) for i in range(len(optimizers))]\n",
+    "\n",
+    "    bars = plt.bar(optimizers, runtimes, color=colors)\n",
+    "\n",
+    "    plt.title(title)\n",
+    "    plt.xlabel(\"optimizer\")\n",
+    "    plt.ylabel(\"total runtime (sec)\")\n",
+    "    plt.xticks(rotation=25, ha=\"right\")\n",
+    "\n",
+    "    # labels on bars (seconds + epochs)\n",
+    "    for bar, rt, ep in zip(bars, runtimes, epochs_total):\n",
+    "        plt.text(\n",
+    "            bar.get_x() + bar.get_width() / 2,\n",
+    "            bar.get_height(),\n",
+    "            f\"{rt:.2f}s\",\n",
+    "            ha=\"center\",\n",
+    "            va=\"bottom\",\n",
+    "            fontsize=10\n",
+    "        )\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "\n",
+    "    if save_figure:\n",
+    "        figure.savefig(save_path, format=\"png\", dpi=150, bbox_inches=\"tight\")\n",
+    "\n",
+    "    plt.show()\n",
+    "\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c86bfc26",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib.patches import Patch\n",
+    "\n",
+    "def create_diagram_single_step_times(\n",
+    "    optimizers_to_experiment: list,\n",
+    "    csv_path: str,\n",
+    "    title: str,\n",
+    "    save_figure: bool,\n",
+    "    save_path: str,\n",
+    "    log_y: bool = False\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Plots single-step (per-update) runtimes.\n",
+    "\n",
+    "    Reads `csv_path` containing rows:\n",
+    "    [optimizer_index, diagThreshold, diagonalFlag, time_sec], maps optimizer_index to\n",
+    "    names via `optimizers_to_experiment`, and builds a bar chart sorted by runtime.\n",
+    "\n",
+    "    For Shampoo variants (\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\"), both\n",
+    "    diagonal and non-diagonal modes are plotted as separate bars (distinguished by\n",
+    "    hatching). For non-Shampoo optimizers, only the fastest measured time is shown.\n",
+    "\n",
+    "    Args:\n",
+    "        optimizers_to_experiment: Optimizer names in the same order as used to write\n",
+    "            optimizer_index in the CSV.\n",
+    "        csv_path: Path to the timing CSV (no header).\n",
+    "        title: Plot title.\n",
+    "        save_figure: If True, saves the plot to `save_path`.\n",
+    "        save_path: Output path for the PNG (only used if `save_figure` is True).\n",
+    "        log_y: If True, uses a log-scaled y-axis for better visibility across\n",
+    "            large runtime differences.\n",
+    "    \"\"\"\n",
+    "    # CSV: optimizer_index, diagThreshold, diagonalFlag, time_sec\n",
+    "    collected_data = pd.read_csv(\n",
+    "        csv_path,\n",
+    "        header=None,\n",
+    "        names=[\"optimizer_index\", \"diagThreshold\", \"diagonal\", \"time_sec\"]\n",
+    "    )\n",
+    "\n",
+    "    # index -> optimizer name\n",
+    "    idx_to_name = {i + 1: optimizers_to_experiment[i] for i in range(len(optimizers_to_experiment))}\n",
+    "    collected_data[\"optimizer\"] = collected_data[\"optimizer_index\"].map(idx_to_name)\n",
+    "\n",
+    "    # diagonalFlag -> string\n",
+    "    collected_data[\"mode\"] = np.where(collected_data[\"diagonal\"] == 1, \"diagonal\", \"non-diagonal\")\n",
+    "\n",
+    "\n",
+    "    shampoo_variants = {\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\"}\n",
+    "\n",
+    "    bars = []  # (label, time_sec, base_optimizer, mode)\n",
+    "    for optimizer in optimizers_to_experiment:\n",
+    "        optimizer_data = collected_data[collected_data[\"optimizer\"] == optimizer].copy()\n",
+    "\n",
+    "        if optimizer in shampoo_variants:\n",
+    "            # both modi ((non)diagonal)\n",
+    "            for mode in [\"diagonal\", \"non-diagonal\"]:\n",
+    "                mode_data = optimizer_data[optimizer_data[\"mode\"] == mode]\n",
+    "                if len(mode_data) == 0:\n",
+    "                    continue\n",
+    "                time_value = float(mode_data[\"time_sec\"].min())\n",
+    "                label = f\"{optimizer} {mode}\"\n",
+    "                bars.append((label, time_value, optimizer, mode))\n",
+    "        else:\n",
+    "            # non-shampoo: take the fastest of both values\n",
+    "            time_value = float(optimizer_data[\"time_sec\"].min())\n",
+    "            label = optimizer\n",
+    "            bars.append((label, time_value, optimizer, \"best\"))\n",
+    "\n",
+    "    # sort from fast to slow\n",
+    "    bars.sort(key=lambda x: x[1])\n",
+    "\n",
+    "    labels = [b[0] for b in bars]\n",
+    "    times = [b[1] for b in bars]\n",
+    "    base_opts = [b[2] for b in bars]\n",
+    "    modes = [b[3] for b in bars]\n",
+    "\n",
+    "    figure = plt.figure(figsize=(15, 7))\n",
+    "\n",
+    "    # per base optimizer one color\n",
+    "    cmap = plt.get_cmap(\"tab10\")\n",
+    "    unique_base = []\n",
+    "    for b in base_opts:\n",
+    "        if b not in unique_base:\n",
+    "            unique_base.append(b)\n",
+    "    color_map = {b: cmap(i % 10) for i, b in enumerate(unique_base)}\n",
+    "    colors = [color_map[b] for b in base_opts]\n",
+    "\n",
+    "    # Hatches: diagonal vs non-diagonal for Shampoo\n",
+    "    hatches = []\n",
+    "    for m in modes:\n",
+    "        if m == \"diagonal\":\n",
+    "            hatches.append(\"//\")\n",
+    "        elif m == \"non-diagonal\":\n",
+    "            hatches.append(\"\")\n",
+    "        else:\n",
+    "            hatches.append(\"\")  # non-shampoo (best)\n",
+    "\n",
+    "    bar_container = plt.bar(labels, times, color=colors)\n",
+    "    for rect, hatch in zip(bar_container, hatches):\n",
+    "        rect.set_hatch(hatch)\n",
+    "\n",
+    "    plt.title(title)\n",
+    "    plt.xlabel(\"optimizer\")\n",
+    "    plt.ylabel(\"time per update (sec)\")\n",
+    "    if log_y:\n",
+    "        plt.yscale(\"log\")\n",
+    "        plt.ylabel(\"time per update (sec, log scale)\")\n",
+    "\n",
+    "    # annotate seconds\n",
+    "    for rect, t in zip(bar_container, times):\n",
+    "        plt.text(\n",
+    "            rect.get_x() + rect.get_width()/2,\n",
+    "            rect.get_height(),\n",
+    "            f\"{t:.2e}s\",\n",
+    "            ha=\"center\",\n",
+    "            va=\"bottom\",\n",
+    "            fontsize=9\n",
+    "        )\n",
+    "\n",
+    "    plt.xticks(rotation=25, ha=\"right\")\n",
+    "\n",
+    "    # legend for Hatches\n",
+    "    legend_handles = [\n",
+    "        Patch(facecolor=\"white\", edgecolor=\"black\", hatch=\"//\", label=\"diagonal (Shampoo only)\"),\n",
+    "        Patch(facecolor=\"white\", edgecolor=\"black\", hatch=\"\", label=\"non-diagonal (Shampoo only)\"),\n",
+    "        Patch(facecolor=\"white\", edgecolor=\"black\", hatch=\"\", label=\"best-case (non-Shampoo)\")\n",
+    "    ]\n",
+    "    plt.legend(handles=legend_handles, loc=\"upper left\")\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "\n",
+    "    if save_figure:\n",
+    "        figure.savefig(save_path, dpi=150, bbox_inches=\"tight\")\n",
+    "\n",
+    "    plt.show()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17953fe6",
+   "metadata": {},
+   "source": [
+    "## Experiment 0: Comparison between shampoo diagonal vs non-diagonal implementations on MNIST and CIFAR10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60fb5090",
+   "metadata": {},
+   "source": [
+    "### Comparison of shampoo vs shampoo_diagonal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c3cdcd44",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_diagonal\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison of shampoo in the diagonal and non-diagonal variant on MNIST\"\n",
+    "save_path = f\"diagrams/shampoo_diagonal_nondiagonal_comparison_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "20cc7da0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_diagonal\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison of shampoo in the diagonal and non-diagonal variant on CIFAR10\"\n",
+    "save_path = f\"diagrams/shampoo_diagonal_nondiagonal_comparison_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9d118e6",
+   "metadata": {},
+   "source": [
+    "### Comparison of shampoo_momentum vs shampoo_momentum_diagonal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "635039e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo_momentum\", \"shampoo_momentum_diagonal\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison of shampoo (momentum) in the diagonal and non-diagonal variant on MNIST\"\n",
+    "save_path = f\"diagrams/shampoo_momentum_diagonal_nondiagonal_comparison_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "98342fff",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo_momentum\", \"shampoo_momentum_diagonal\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison of shampoo (momentum) in the diagonal and non-diagonal variant on CIFAR10\"\n",
+    "save_path = f\"diagrams/shampoo_momentum_diagonal_nondiagonal_comparison_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c83fbdc",
+   "metadata": {},
+   "source": [
+    "### Comparison of shampoo_heuristic vs shampoo_heuristic_diagonal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "24b8baca",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo_heuristic\", \"shampoo_heuristic_diagonal\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison of shampoo (heuristic) in the diagonal and non-diagonal variant on MNIST\"\n",
+    "save_path = f\"diagrams/shampoo_heuristic_diagonal_nondiagonal_comparison_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "9c171be1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo_heuristic\", \"shampoo_heuristic_diagonal\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison of shampoo (heuristic) in the diagonal and non-diagonal variant on CIFAR10\"\n",
+    "save_path = f\"diagrams/shampoo_heuristic_diagonal_nondiagonal_comparison_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b47088e9",
+   "metadata": {},
+   "source": [
+    "## Experiment 1: Comparison between shampoo implementations on MNIST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "9fccabd1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between the shampoo implementations on MNIST\"\n",
+    "save_path = f\"diagrams/shampoo_implementations_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "571480c8",
+   "metadata": {},
+   "source": [
+    "## Experiment 2: Comparison between shampoo and typical optimizers on MNIST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "71b7b4da",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\", \"adam\", \"sgd\", \"adagrad\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between multiple variants of the shampoo optimizer, adam, sgd and adagrad on MNIST\"\n",
+    "save_path = f\"diagrams/total_comparison_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4b5fb5f",
+   "metadata": {},
+   "source": [
+    "## Experiment 3: Comparison between shampoo implementations on CIFAR10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "95f30bae",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between the shampoo implementations on CIFAR10\"\n",
+    "save_path = f\"diagrams/shampoo_implementations_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f87f35c",
+   "metadata": {},
+   "source": [
+    "## Experiment 4: Comparison between shampoo and typical optimizers on CIFAR10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "cd26bda9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\1115652710.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\", \"adam\", \"sgd\", \"adagrad\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between multiple variants of the shampoo optimizer, adam, sgd and adagrad on CIFAR10\"\n",
+    "save_path = f\"diagrams/total_comparison_{dataset}.png\"\n",
+    "\n",
+    "create_diagram(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7ef94ffa",
+   "metadata": {},
+   "source": [
+    "## Experiment 5: Time until convergence on MNIST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "34a2fd54",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2538760060.py:30: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\", \"adam\", \"sgd\", \"adagrad\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between convergence times on MNIST\"\n",
+    "save_path = f\"diagrams/convergence_times_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_convergence(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "64732215",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2538760060.py:30: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_diagonal\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between convergence times of shampoo diagonal and non-diagonal on MNIST\"\n",
+    "save_path = f\"diagrams/convergence_times_shampoo_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_convergence(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "4ed69e80",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2538760060.py:30: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo_momentum\", \"shampoo_momentum_diagonal\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between convergence times of shampoo (momentum) diagonal and non-diagonal on MNIST\"\n",
+    "save_path = f\"diagrams/convergence_times_shampoo_momentum_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_convergence(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "916443f2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2538760060.py:30: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo_heuristic\", \"shampoo_heuristic_diagonal\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between convergence times of shampoo (heuristic) diagonal and non-diagonal on MNIST\"\n",
+    "save_path = f\"diagrams/convergence_times_shampoo_heuristic_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_convergence(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "67493b77",
+   "metadata": {},
+   "source": [
+    "## Experiment 6: Time until convergence on CIFAR10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "b8eaa4de",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2538760060.py:30: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABN4AAAL8CAYAAAA/RXghAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAADIMUlEQVR4nOzdd3xO9///8WcSssgQZCAipbU31dgzQShFjQ6zRhtVtKh+1KpKVRWtopOOaO1RJcSIXVTFFitKEbRI7JC8f3/45fr2aoJEczUNj/vtdt1urvf7fc55nZMrV/XpvN/HzhhjBAAAAAAAACBL2Wd3AQAAAAAAAMDDiOANAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQCAR5SdnZ1GjhyZ3WWkq1ixYmrRokV2lwH8J9SvX1/169fP7jIAAMADIHgDADyyjh49qt69e+uxxx6Ts7Oz3N3dVatWLU2ePFnXr1/P7vKQha5du6aRI0cqOjo6u0sB0rV//36NHDlSx48fz+5ScqSFCxeqWbNmKlCggBwdHVWoUCG1b99ea9assYyJjo6WnZ2d5s2bZ2mbOXOm7Ozs0n29+eabVseYOnWq7OzsVKNGjbvW8fd9uLu7q169evrpp5+y/qQBADlCruwuAACA7PDTTz/p2WeflZOTkzp37qxy5copKSlJGzdu1KBBg7Rv3z599tln2V2mTV2/fl25cj0afxW4du2aRo0aJUncOYT/pP3792vUqFGqX7++ihUrZtW3cuXK7CkqBzDGqHv37po5c6YqV66sgQMHytfXV2fOnNHChQvVqFEjbdq0STVr1rznfkaPHq3AwECrtnLlylm9j4iIULFixbRt2zYdOXJEJUqUSHdfTZo0UefOnWWM0W+//aZp06apZcuWWr58uUJCQv7ZCQMAcpxH42/bAAD8RVxcnDp27KiAgACtWbNGfn5+lr6wsDAdOXLkob07ISUlRUlJSXJ2dpazs3N2lwPclzFGN27ckIuLS3aXkm0cHR2zu4T/rAkTJmjmzJnq37+/PvzwQ9nZ2Vn6/ve//+nbb7/N0D8wNGvWTNWqVbtrf1xcnDZv3qwFCxaod+/eioiI0IgRI9Id+8QTT+iFF16wvG/btq3KlCmjyZMnE7wBwCOIqaYAgEfO+++/rytXrujLL7+0Ct1SlShRQq+99prl/e3bt/XOO++oePHicnJyUrFixfTWW2/p5s2bVtulrksWHR2tatWqycXFReXLl7dMb1ywYIHKly8vZ2dnVa1aVTt37rTavmvXrsqbN6+OHTumkJAQ5cmTR4UKFdLo0aNljLEa+8EHH6hmzZrKnz+/XFxcVLVqVavpU6ns7OzUt29fRUREqGzZsnJyclJkZKSl769rvF2+fFn9+/dXsWLF5OTkJG9vbzVp0kS//vqr1T7nzp2rqlWrysXFRQUKFNALL7ygU6dOpXsup06dUuvWrZU3b14VLFhQb7zxhpKTk+/yk0lr5cqVqlSpkpydnVWmTBktWLAgzZhLly6pf//+8vf3l5OTk0qUKKFx48YpJSVFknT8+HEVLFhQkjRq1CjLFLCRI0dqyZIlsrOz0+7duy37mz9/vuzs7NSmTRur45QuXVodOnSwavvuu+8s18LLy0sdO3bUyZMn09S4detWNW3aVB4eHnJ1dVW9evW0adMmqzEjR46UnZ2djhw5oq5du8rT01MeHh7q1q2brl27lqHrtXXrVjVv3lz58uVTnjx5VKFCBU2ePNlqzJo1a1SnTh3lyZNHnp6eatWqlQ4cOPBAtZQrV04NGjRIU0dKSooKFy6sdu3aWbVNmjRJZcuWlbOzs3x8fNS7d29dvHjRatvU36MVK1ZYfo8+/fRTSdJvv/2mp59+Wnny5JG3t7cGDBigFStWyM7OLs00Yltc8++++05PPvmkXF1dlS9fPtWtWzfN3WjLly+3XF83NzeFhoZq3759afb1VzNnztSzzz4rSWrQoIHlM5p6Tn9f4y11yuScOXM0atQoFS5cWG5ubmrXrp0SEhJ08+ZN9e/fX97e3sqbN6+6deuW5vsq9Xzu9/k9fPiw2rZtK19fXzk7O6tIkSLq2LGjEhIS7nlOku2/K65fv67w8HCVKlVKH3zwgVXolurFF1/Uk08+ed9a7yciIkL58uVTaGio2rVrp4iIiAxvW7p0aRUoUEBHjx79x3UAAHIegjcAwCPnxx9/1GOPPXbfqUepXnrpJQ0fPlxVqlTRxIkTVa9ePYWHh6tjx45pxh45ckTPPfecWrZsqfDwcF28eFEtW7ZURESEBgwYoBdeeEGjRo3S0aNH1b59e0s4lCo5OVlNmzaVj4+P3n//fVWtWlUjRoxIc2fF5MmTVblyZY0ePVpjx45Vrly59Oyzz6Z7p96aNWs0YMAAdejQQZMnT04zjS1Vnz59NG3aNLVt21ZTp07VG2+8IRcXF6tQZubMmWrfvr0cHBwUHh6unj17asGCBapdu7YuXbqU5lxCQkKUP39+ffDBB6pXr54mTJiQ4Sm8hw8fVocOHdSsWTOFh4dbzjEqKsoy5tq1a6pXr56+++47de7cWR999JFq1aqloUOHauDAgZKkggULatq0aZKkZ555Rt9++62+/fZbtWnTRrVr15adnZ3Wr19v2eeGDRtkb2+vjRs3WtrOnz+vgwcPqm7dupa2d999V507d9bjjz+uDz/8UP3799fq1atVt25dq2uxZs0a1a1bV4mJiRoxYoTGjh2rS5cuqWHDhtq2bVua827fvr0uX76s8PBwtW/fXjNnzrRMk72XqKgo1a1bV/v379drr72mCRMmqEGDBlq6dKllzKpVqxQSEqJz585p5MiRGjhwoDZv3qxatWqlu7bY/Wrp0KGD1q9fr/j4eKvtNm7cqNOnT1v9jvTu3VuDBg2yrKPYrVs3RUREKCQkRLdu3bLaPjY2Vp06dVKTJk00efJkVapUSVevXlXDhg21atUq9evXT//73/+0efNmDRkyJE3dtrjmo0aN0osvvqjcuXNr9OjRGjVqlPz9/a3WEPv2228VGhqqvHnzaty4cXr77be1f/9+1a5d+55rt9WtW1f9+vWTJL311luWz2jp0qXvuo0khYeHa8WKFXrzzTfVvXt3LViwQH369FH37t116NAhjRw5Um3atNHMmTM1btw4q20z8vlNSkpSSEiIfv75Z7366qv65JNP1KtXLx07dizN7/vf/RvfFRs3btSFCxf03HPPycHB4Z5j7ychIUF//PGH1euvIiIi1KZNGzk6OqpTp046fPiwtm/fnuF9X7x4Ufny5ftHNQIAcigDAMAjJCEhwUgyrVq1ytD4mJgYI8m89NJLVu1vvPGGkWTWrFljaQsICDCSzObNmy1tK1asMJKMi4uL+e233yztn376qZFk1q5da2nr0qWLkWReffVVS1tKSooJDQ01jo6O5vz585b2a9euWdWTlJRkypUrZxo2bGjVLsnY29ubffv2pTk3SWbEiBGW9x4eHiYsLOyu1yIpKcl4e3ubcuXKmevXr1valy5daiSZ4cOHpzmX0aNHW+2jcuXKpmrVqnc9RqrUazl//nxLW0JCgvHz8zOVK1e2tL3zzjsmT5485tChQ1bbv/nmm8bBwcGcOHHCGGPM+fPn05xvqrJly5r27dtb3lepUsU8++yzRpI5cOCAMcaYBQsWGElm165dxhhjjh8/bhwcHMy7775rta89e/aYXLlyWdpTUlLM448/bkJCQkxKSopl3LVr10xgYKBp0qSJpW3EiBFGkunevbvVPp955hmTP3/+e16v27dvm8DAQBMQEGAuXrxo1ffX41aqVMl4e3ubP//809K2a9cuY29vbzp37pzpWmJjY40k8/HHH1uNe+WVV0zevHktn9MNGzYYSSYiIsJqXGRkZJr21J99ZGSk1dgJEyYYSWbRokWWtuvXr5tSpUpZ/S7Z4pofPnzY2Nvbm2eeecYkJydbjU09xuXLl42np6fp2bOnVX98fLzx8PBI0/53c+fOTfOdkKpevXqmXr16lvdr1641kky5cuVMUlKSpb1Tp07Gzs7ONGvWzGr7oKAgExAQYHmf0c/vzp07jSQzd+7ce9b+d//Wd8XkyZONJLNw4cIM1ZV63f56PjNmzDCS0n2l+uWXX4wkExUVZYy58zMvUqSIee2119IcQ5Lp0aOHOX/+vDl37pz55ZdfTNOmTY0kM378+AzVCQB4uHDHGwDgkZKYmChJcnNzy9D4ZcuWSZLl7qlUr7/+uiSlucOsTJkyCgoKsrxPffpdw4YNVbRo0TTtx44dS3PMvn37Wv6cOlU0KSlJq1atsrT/db2rixcvKiEhQXXq1EkzLVSS6tWrpzJlytznTCVPT09t3bpVp0+fTrf/l19+0blz5/TKK69YrQ8XGhqqUqVKpXu3XZ8+faze16lTJ91zTk+hQoX0zDPPWN67u7urc+fO2rlzp+UOq7lz56pOnTrKly+f1Z0qjRs3VnJystWdbHdTp04dbdiwQdKd6ba7du1Sr169VKBAAUv7hg0b5OnpaVlsfcGCBUpJSVH79u2tjuvr66vHH39ca9eulSTFxMTo8OHDeu655/Tnn39axl29elWNGjXS+vXr09z1mN41+/PPPy2f3fTs3LlTcXFx6t+/vzw9Pa36UqffnTlzRjExMeratau8vLws/RUqVFCTJk0sn/XM1PLEE0+oUqVKmj17tmVMcnKy5s2bp5YtW1o+p3PnzpWHh4eaNGlidb2qVq2qvHnzWq5XqsDAwDRrYUVGRqpw4cJ6+umnLW3Ozs7q2bOn1ThbXPNFixYpJSVFw4cPl7299V+fU69vVFSULl26pE6dOlmdo4ODg2rUqJHmHLNC586dlTt3bsv7GjVqWB428Fc1atTQyZMndfv2bUkZ//x6eHhIklasWJHh6c7Sv/ddkdnv83v55JNPFBUVZfVKFRERIR8fH8u0ajs7O3Xo0EE//PBDutNhv/zySxUsWFDe3t6qVq2aVq9ercGDB6f57wgA4NHAwxUAAI8Ud3d3SXcCloz47bffZG9vn+bpdb6+vvL09NRvv/1m1f7XcE36v/9x9ff3T7f97+tb2dvb67HHHrNqe+KJJyTJaqra0qVLNWbMGMXExFit3ZTeGkd/f1Lf3bz//vvq0qWL/P39VbVqVTVv3lydO3e21JN6riVLlkyzbalSpaymZkp3QpHUtdVS5cuXL805302JEiXSnM9fr4Wvr68OHz6s3bt3pzlOqnPnzt33OHXq1NH06dN15MgRHT16VHZ2dgoKCrIEcj179tSGDRtUq1YtS+hy+PBhGWP0+OOPp7vP1DDk8OHDkqQuXbrc9fgJCQlWU9D+/hlK7bt48aLl8/t3qWtH/f0pjH91r59f6dKltWLFCl29elV58uTJVC0dOnTQW2+9pVOnTqlw4cKKjo7WuXPnrNbDO3z4sBISEuTt7Z1ubX//OaX3mf3tt99UvHjxNJ+Jv/9u2uKaHz16VPb29vcMsFOP27Bhw3T77/az+ycy832TkpKihIQE5c+fP8Of38DAQA0cOFAffvihIiIiVKdOHT399NN64YUXLMdKz7/1XZHZ7/N7efLJJ9N9uEJycrJ++OEHNWjQQHFxcZb2GjVqaMKECVq9erWCg4OttmnVqpXlH0y2b9+usWPH6tq1a2lCWwDAo4HgDQDwSHF3d1ehQoW0d+/eTG2XXqCVnrutM3S3dvO3hyZkxIYNG/T000+rbt26mjp1qvz8/JQ7d27NmDFDs2bNSjM+o0+DbN++verUqaOFCxdq5cqVGj9+vMaNG6cFCxaoWbNmma7zn665lBEpKSlq0qSJBg8enG5/alB3L7Vr15YkrV+/XseOHVOVKlWUJ08e1alTRx999JGuXLminTt36t1337U6rp2dnZYvX57ueebNm9cyTpLGjx+vSpUqpXv81LGpsvKz8k9lpJYOHTpo6NChmjt3rvr37685c+bIw8NDTZs2tYxJSUmRt7f3XRek/3vo8k+eYJpd1zz1uN9++618fX3T9GfkyZqZ9aDfNxn9/Ep3nhratWtXLV68WCtXrlS/fv0UHh6un3/+WUWKFMmCs3jw74pSpUpJkvbs2aPWrVtnSS1/t2bNGp05c0Y//PCDfvjhhzT9ERERaYK3IkWKqHHjxpKk5s2bq0CBAurbt68aNGiQ5qEtAICHH8EbAOCR06JFC3322WfasmWL1bTQ9AQEBCglJUWHDx+2Wuj87NmzunTpkgICArK0tpSUFB07dswqMDp06JAkWR6KMH/+fDk7O2vFihVycnKyjJsxY8Y/Pr6fn59eeeUVvfLKKzp37pyqVKmid999V82aNbOca2xsbJq7emJjY7P8Whw5ckTGGKvQ8+/Xonjx4rpy5Yrlf3Lv5l7BadGiRVW0aFFt2LBBx44dU506dSTdWfB+4MCBmjt3rpKTk60erFC8eHEZYxQYGHjPcK948eKS7gS+96vxn0g9zt69e+96nL/+/P7u4MGDKlCggNXdbhkVGBioJ598UrNnz1bfvn21YMECtW7d2uqzWbx4ca1atUq1atV64FAtICBA+/fvT/OZOHLkiNU4W1zz4sWLKyUlRfv3779rmJd6XG9v7wc6bkbD/ayQ0c9vqvLly6t8+fIaNmyY5WEc06dP15gxY9Id/299V9SuXVv58uXT999/r7feessmYX9ERIS8vb31ySefpOlbsGCBFi5cqOnTp9/zc927d29NnDhRw4YN0zPPPPOv/qwBANmP+50BAI+cwYMHK0+ePHrppZd09uzZNP1Hjx7V5MmTJd25W0GSJk2aZDXmww8/lHRnzaKsNmXKFMufjTGaMmWKcufOrUaNGkm6c3eInZ2d1dpCx48f16JFix74mMnJyUpISLBq8/b2VqFChSxTWatVqyZvb29Nnz7danrr8uXLdeDAgSy/FqdPn9bChQst7xMTE/XNN9+oUqVKljuK2rdvry1btmjFihVptr906ZJlTStXV1dLW3rq1KmjNWvWaNu2bZbgrVKlSnJzc9N7770nFxcXVa1a1TK+TZs2cnBw0KhRo9LcFWWM0Z9//ilJqlq1qooXL64PPvhAV65cSXPc8+fPZ/Ry3FOVKlUUGBioSZMmpTnH1Pr8/PxUqVIlff3111Zj9u7dq5UrV1o+6w+iQ4cO+vnnn/XVV1/pjz/+sJpmKt35OSUnJ+udd95Js+3t27fv+4RMSQoJCdGpU6e0ZMkSS9uNGzf0+eefW42zxTVv3bq17O3tNXr06DTrw6Ve35CQELm7u2vs2LFpntKakeOmhp4ZuRb/VEY/v4mJiZbfoVTly5eXvb291XfA3/1b3xWurq4aMmSIDhw4oCFDhqR7h+J3332X7pNsM+L69etasGCBWrRooXbt2qV59e3bV5cvX7b6TKYnV65cev3113XgwAEtXrz4gWoBAORc3PEGAHjkFC9eXLNmzVKHDh1UunRpde7cWeXKlVNSUpI2b96suXPnqmvXrpKkihUrqkuXLvrss8906dIl1atXT9u2bdPXX3+t1q1bWxbbzirOzs6KjIxUly5dVKNGDS1fvlw//fST3nrrLct0vNDQUH344Ydq2rSpnnvuOZ07d06ffPKJSpQood27dz/QcS9fvqwiRYqoXbt2qlixovLmzatVq1Zp+/btmjBhgqQ76z6NGzdO3bp1U7169dSpUyedPXtWkydPVrFixTRgwIAsuw7SnWmiPXr00Pbt2+Xj46OvvvpKZ8+etbqzb9CgQVqyZIlatGihrl27qmrVqrp69ar27NmjefPm6fjx4ypQoIBcXFxUpkwZzZ49W0888YS8vLxUrlw5y5poderUUUREhOzs7CxTTx0cHFSzZk2tWLFC9evXl6Ojo+W4xYsX15gxYzR06FAdP35crVu3lpubm+Li4rRw4UL16tVLb7zxhuzt7fXFF1+oWbNmKlu2rLp166bChQvr1KlTWrt2rdzd3fXjjz/+42tlb2+vadOmqWXLlqpUqZK6desmPz8/HTx4UPv27bMEk+PHj1ezZs0UFBSkHj166Pr16/r444/l4eGhkSNHPvDx27dvrzfeeENvvPGGvLy80tzxVa9ePfXu3Vvh4eGKiYlRcHCwcufOrcOHD2vu3LmaPHmy2rVrd89j9O7dW1OmTFGnTp302muvyc/PTxEREZbF+1PvIrLFNS9RooT+97//6Z133lGdOnXUpk0bOTk5afv27SpUqJDCw8Pl7u6uadOm6cUXX1SVKlXUsWNHFSxYUCdOnNBPP/2kWrVqWYXqf1epUiU5ODho3LhxSkhIkJOTkxo2bHjXdfH+iYx+ftesWaO+ffvq2Wef1RNPPKHbt2/r22+/lYODg9q2bXvX/f+b3xWDBg3Svn37NGHCBK1du1bt2rWTr6+v4uPjtWjRIm3btk2bN29+oH0vWbJEly9ftnqgx1899dRTKliwoCIiItKEzX/XtWtXDR8+XOPGjbPZtFgAwH/Uv/sQVQAA/jsOHTpkevbsaYoVK2YcHR2Nm5ubqVWrlvn444/NjRs3LONu3bplRo0aZQIDA03u3LmNv7+/GTp0qNUYY4wJCAgwoaGhaY4jyYSFhVm1xcXFGUlm/PjxlrYuXbqYPHnymKNHj5rg4GDj6upqfHx8zIgRI0xycrLV9l9++aV5/PHHjZOTkylVqpSZMWOGGTFihPn7f9rTO/Zf+0aMGGGMMebmzZtm0KBBpmLFisbNzc3kyZPHVKxY0UydOjXNdrNnzzaVK1c2Tk5OxsvLyzz//PPm999/txqTei5/l16N6Um9litWrDAVKlSwnOfcuXPTjL18+bIZOnSoKVGihHF0dDQFChQwNWvWNB988IFJSkqyjNu8ebOpWrWqcXR0tDp3Y4zZt2+fkWRKly5tte8xY8YYSebtt99Ot8758+eb2rVrmzx58pg8efKYUqVKmbCwMBMbG2s1bufOnaZNmzYmf/78xsnJyQQEBJj27dub1atXp7k258+ft9p2xowZRpKJi4u773XbuHGjadKkieVnWKFCBfPxxx9bjVm1apWpVauWcXFxMe7u7qZly5Zm//79VmMepJZatWoZSeall166a32fffaZqVq1qnFxcTFubm6mfPnyZvDgweb06dOWMXf7PTLGmGPHjpnQ0FDj4uJiChYsaF5//XUzf/58I8n8/PPPVmNtcc2/+uory2c/X758pl69eiYqKspqzNq1a01ISIjx8PAwzs7Opnjx4qZr167ml19+uet1SfX555+bxx57zDg4OBhJZu3atcYYY+rVq2fq1atndQxJaX4fUuvevn27VfvdzvN+n99jx46Z7t27m+LFixtnZ2fj5eVlGjRoYFatWnXfczHm3/muSDVv3jwTHBxsvLy8TK5cuYyfn5/p0KGDiY6OtoxJ77rd7ZoZY0zLli2Ns7OzuXr16l2P27VrV5M7d27zxx9/GGPu/Z07cuRIq58rAODRYGdMNqzUCwAA0ujatavmzZuX7vQ4AOmbNGmSBgwYoN9//12FCxfO7nIAAACssMYbAAAAcoTr169bvb9x44Y+/fRTPf7444RuAADgP4k13gAAAJAjtGnTRkWLFlWlSpWUkJCg7777TgcPHlRERER2lwYAAJAugjcAAADkCCEhIfriiy8UERGh5ORklSlTRj/88MN9F7YHAADILqzxBgAAAAAAANgAa7wBAAAAAAAANkDwBgAAAAAAANgAa7xlQEpKik6fPi03NzfZ2dlldzkAAAAAAADIRsYYXb58WYUKFZK9/d3vayN4y4DTp0/L398/u8sAAAAAAADAf8jJkydVpEiRu/YTvGWAm5ubpDsX093dPZurAQAAAAAAQHZKTEyUv7+/JTO6G4K3DEidXuru7k7wBgAAAAAAAEm675JkPFwBAAAAAAAAsIFsDd6mTZumChUqWO4kCwoK0vLlyy39N27cUFhYmPLnz6+8efOqbdu2Onv2rNU+Tpw4odDQULm6usrb21uDBg3S7du3rcZER0erSpUqcnJyUokSJTRz5sx/4/QAAAAAAADwCMvW4K1IkSJ67733tGPHDv3yyy9q2LChWrVqpX379kmSBgwYoB9//FFz587VunXrdPr0abVp08ayfXJyskJDQ5WUlKTNmzfr66+/1syZMzV8+HDLmLi4OIWGhqpBgwaKiYlR//799dJLL2nFihX/+vkCAAAAAADg0WFnjDHZXcRfeXl5afz48WrXrp0KFiyoWbNmqV27dpKkgwcPqnTp0tqyZYueeuopLV++XC1atNDp06fl4+MjSZo+fbqGDBmi8+fPy9HRUUOGDNFPP/2kvXv3Wo7RsWNHXbp0SZGRkRmqKTExUR4eHkpISGCNNwAAAAAAgEdcRrOi/8wab8nJyfrhhx909epVBQUFaceOHbp165YaN25sGVOqVCkVLVpUW7ZskSRt2bJF5cuXt4RukhQSEqLExETLXXNbtmyx2kfqmNR9pOfmzZtKTEy0egEAAAAAAACZke3B2549e5Q3b145OTmpT58+WrhwocqUKaP4+Hg5OjrK09PTaryPj4/i4+MlSfHx8VahW2p/at+9xiQmJur69evp1hQeHi4PDw/Ly9/fPytOFQAAAAAAAI+QbA/eSpYsqZiYGG3dulUvv/yyunTpov3792drTUOHDlVCQoLldfLkyWytBwAAAAAAADlPruwuwNHRUSVKlJAkVa1aVdu3b9fkyZPVoUMHJSUl6dKlS1Z3vZ09e1a+vr6SJF9fX23bts1qf6lPPf3rmL8/CfXs2bNyd3eXi4tLujU5OTnJyckpS84PAAAAAAAAj6Zsv+Pt71JSUnTz5k1VrVpVuXPn1urVqy19sbGxOnHihIKCgiRJQUFB2rNnj86dO2cZExUVJXd3d5UpU8Yy5q/7SB2Tug8AAAAAAADAFrL1jrehQ4eqWbNmKlq0qC5fvqxZs2YpOjpaK1askIeHh3r06KGBAwfKy8tL7u7uevXVVxUUFKSnnnpKkhQcHKwyZcroxRdf1Pvvv6/4+HgNGzZMYWFhljvW+vTpoylTpmjw4MHq3r271qxZozlz5uinn37KzlMHAAAAAADAQy5bg7dz586pc+fOOnPmjDw8PFShQgWtWLFCTZo0kSRNnDhR9vb2atu2rW7evKmQkBBNnTrVsr2Dg4OWLl2ql19+WUFBQcqTJ4+6dOmi0aNHW8YEBgbqp59+0oABAzR58mQVKVJEX3zxhUJCQv718wUAAAAAAMCjw84YY7K7iP+6xMREeXh4KCEhQe7u7tldDgAAAAAAALJRRrOi/9wabwAAAAAAAMDDgOANAAAAAAAAsAGCNwAAAAAAkOOFh4erevXqcnNzk7e3t1q3bq3Y2FirMfHx8XrxxRfl6+urPHnyqEqVKpo/f77VmF9//VVNmjSRp6en8ufPr169eunKlSuW/j///FNNmzZVoUKF5OTkJH9/f/Xt21eJiYkZqvPmzZuqVKmS7OzsFBMTY9U3Z84cVapUSa6urgoICND48eMf7GLgP4PgDQAAAAAeMVkVUBw6dEitWrVSgQIF5O7urtq1a2vt2rVpjjdz5kxVqFBBzs7O8vb2VlhY2H1r3LJlixo2bKg8efLI3d1ddevW1fXr163G/PTTT6pRo4ZcXFyUL18+tW7dOvMXAw+NdevWKSwsTD///LOioqJ069YtBQcH6+rVq5YxnTt3VmxsrJYsWaI9e/aoTZs2at++vXbu3ClJOn36tBo3bqwSJUpo69atioyM1L59+9S1a1fLPuzt7dWqVSstWbJEhw4d0syZM7Vq1Sr16dMnQ3UOHjxYhQoVStO+fPlyPf/88+rTp4/27t2rqVOnauLEiZoyZco/uzDIXgb3lZCQYCSZhISE7C4FAAAAAP6xkJAQM2PGDLN3714TExNjmjdvbooWLWquXLliGdOkSRNTvXp1s3XrVnP06FHzzjvvGHt7e/Prr79axjz++OOmefPmZteuXebQoUPmlVdeMa6urubMmTOWMRMmTDCFChUyERER5siRI2bXrl1m8eLF96xv8+bNxt3d3YSHh5u9e/eagwcPmtmzZ5sbN25YxsybN8/ky5fPTJs2zcTGxpp9+/aZ2bNnZ+FVQk537tw5I8msW7fO0pYnTx7zzTffWI3z8vIyn3/+uTHGmE8//dR4e3ub5ORkS//u3buNJHP48OG7Hmvy5MmmSJEi961p2bJlplSpUmbfvn1Gktm5c6elr1OnTqZdu3ZW4z/66CNTpEgRk5KSYowxJiYmxtSvX9/kzZvXuLm5mSpVqpjt27ff97jIehnNinJla+oHAAAAAPjXRUZGWr2fOXOmvL29tWPHDtWtW1eStHnzZk2bNk1PPvmkJGnYsGGaOHGiduzYocqVK+uPP/7Q4cOH9eWXX6pChQqSpPfee09Tp07V3r175evrq4sXL2rYsGH68ccf1ahRI8vxUsffzYABA9SvXz+9+eablraSJUta/nz79m299tprGj9+vHr06GFpL1OmjOXPFy9eVN++fbVy5UpduXJFRYoU0VtvvaVu3bpl9nIhh0pISJAkeXl5Wdpq1qyp2bNnKzQ0VJ6enpozZ45u3Lih+vXrS7ozDdTR0VH29v83QdDFxUWStHHjRpUoUSLNcU6fPq0FCxaoXr1696zn7Nmz6tmzpxYtWiRXV9c0/Tdv3kzT7uLiot9//12//fabihUrpueff16VK1fWtGnT5ODgoJiYGOXOnTtjFwTZgqmmAAAAAPCIu1dAceHCBaWkpOiHH36wCijy58+vkiVL6ptvvtHVq1d1+/Ztffrpp/L29lbVqlUlSVFRUUpJSdGpU6dUunRpFSlSRO3bt9fJkyfvWsu5c+e0detWeXt7q2bNmvLx8VG9evW0ceNGy5hff/1Vp06dkr29vSpXriw/Pz81a9ZMe/futYx5++23tX//fi1fvlwHDhzQtGnTVKBAgay8bPgPS0lJUf/+/VWrVi2VK1fO0j5nzhzdunVL+fPnl5OTk3r37q2FCxdaArWGDRsqPj5e48ePV1JSki5evGgJgM+cOWN1jE6dOsnV1VWFCxeWu7u7vvjii7vWY4xR165d1adPH1WrVi3dMSEhIVqwYIFWr16tlJQUHTp0SBMmTLA69okTJ9S4cWOVKlVKjz/+uJ599llVrFjxwS8UbI7gDQAAAAAeYQ8aUNjZ2WnVqlXauXOn3Nzc5OzsrA8//FCRkZHKly+fJOnYsWNKSUnR2LFjNWnSJM2bN08XLlxQkyZNlJSUlG49x44dkySNHDlSPXv2VGRkpKpUqaJGjRrp8OHDacYMGzZMS5cuVb58+VS/fn1duHBB0p2AonLlyqpWrZqKFSumxo0bq2XLlra5iPjPCQsL0969e/XDDz9Ytb/99tu6dOmSVq1apV9++UUDBw5U+/bttWfPHklS2bJl9fXXX2vChAlydXWVr6+vAgMD5ePjY3UXnCRNnDhRv/76qxYvXqyjR49q4MCBd63n448/1uXLlzV06NC7junZs6f69u2rFi1ayNHRUU899ZQ6duwoSZZjDxw4UC+99JIaN26s9957T0ePHn2g64N/0b8z8zVnY403AAAAAA+rPn36mICAAHPy5Emr9r59+5onn3zSrFq1ysTExJiRI0caDw8Ps3v3bmOMMSkpKebpp582zZo1Mxs3bjQ7duwwL7/8silcuLA5ffq0McaYd99910gyK1assOz33Llzxt7e3kRGRqZbz6ZNm4wkM3ToUKv28uXLmzfffNMYY0xERISRZD799FNL/40bN0yBAgXM9OnTjTF31tJycXExFStWNIMGDTKbNm36h1cKOUVYWJgpUqSIOXbsmFX7kSNHjCSzd+9eq/ZGjRqZ3r17p9lPfHy8uXz5srly5Yqxt7c3c+bMuesxN2zYYCRZPvt/16pVK2Nvb28cHBwsL0nGwcHBdO7c2Wrs7du3ze+//25u3rxpli1bZiSZc+fOWfpjY2PNhx9+aJo0aWIcHR3NggUL7ntNkPUymhVxxxsAAAAAPKL69u2rpUuXau3atSpSpIil/ejRo5oyZYq++uorNWrUSBUrVtSIESNUrVo1ffLJJ5KkNWvWaOnSpfrhhx9Uq1YtValSRVOnTpWLi4u+/vprSZKfn58k67XXChYsqAIFCujEiRPp1pTeNpJUunRpyzbpjXFyctJjjz1mGdOsWTP99ttvGjBggE6fPq1GjRrpjTfeePCLhf88Y4z69u2rhQsXas2aNQoMDLTqv3btmiSluXPNwcFBKSkpafbn4+OjvHnzavbs2XJ2dlaTJk3ueuzU7W/evJlu/0cffaRdu3YpJiZGMTExWrZsmSRp9uzZevfdd9PUU7hwYTk6Our7779XUFCQChYsaOl/4oknNGDAAK1cuVJt2rTRjBkz7loXsh8PVwAAAACAR4wxRq+++qoWLlyo6OjoBwoo7jbG3t7eMqZWrVqSpNjYWEuwd+HCBf3xxx8KCAhIt7ZixYqpUKFCio2NtWo/dOiQmjVrJkmqWrWqnJycFBsbq9q1a0uSbt26pePHj1vtt2DBgurSpYu6dOmiOnXqaNCgQfrggw8ycomQA4WFhWnWrFlavHix3NzcFB8fL0ny8PCQi4uLSpUqpRIlSqh379764IMPlD9/fi1atEhRUVFaunSpZT9TpkxRzZo1lTdvXkVFRWnQoEF677335OnpKUlatmyZzp49q+rVqytv3rzat2+fBg0apFq1aqlYsWKSpG3btqlz585avXq1ChcurKJFi1rVmjdvXklS8eLFLb8bf/zxh+bNm6f69evrxo0bmjFjhubOnat169ZJkq5fv65BgwapXbt2CgwM1O+//67t27erbdu2trys+Kf+lfvvcjimmgIAADy6xo4da6pVq2by5s1rChYsaFq1amUOHjxoNebMmTPmhRdeMD4+PsbV1dVUrlzZzJs3L9393bhxw1SsWNFIMjt37rTqi4yMNDVq1DB58+Y1BQoUMG3atDFxcXH3rK9ly5bG39/fODk5GV9fX/PCCy+YU6dOpTv28OHDJm/evMbDwyOjp4+H1Msvv2w8PDxMdHS0OXPmjOV17do1Y4wxSUlJpkSJEqZOnTpm69at5siRI+aDDz4wdnZ25qeffjLGGHP+/HmTP39+06ZNGxMTE2NiY2PNG2+8YXLnzm1iYmIsx2rVqpUpW7as2bRpk9mzZ49p0aKFKVOmjElKSjLGGPP777+bkiVLmq1bt1q2mThxonF3dzdz5841hw8fNsOGDTPOzs7myJEjljGvvfaaKVy4sFmxYoU5ePCg6dGjh/H29jYXLlwwxhjz9ttvm0WLFpnDhw+bvXv3mhYtWpgnn3zS5tcW2UdSuq8ZM2ZYxhw6dMi0adPGeHt7G1dXV1OhQgXzzTffWO3nxRdfNF5eXsbR0THd/jVr1pigoCDj4eFhnJ2dzeOPP26GDBliLl68aBmzdu1aI+mu3+FxcXFp/jtw/vx589RTT5k8efIYV1dX06hRI/Pzzz9b+m/evGk6duxo/P39jaOjoylUqJDp27evuX79+gNfMzy4jGZFBG8ZQPAGAADw6AoJCTEzZswwe/fuNTExMaZ58+amaNGi5sqVK5YxTZo0MdWrVzdbt241R48eNe+8846xt7c3v/76a5r99evXzzRr1izN/3AdO3bMODk5maFDh5ojR46YHTt2mLp165rKlSvfs74PP/zQbNmyxRw/ftxs2rTJBAUFmaCgoDTjkpKSTLVq1UyzZs0I3pBlAcX27dtNcHCw8fLyMm5ubuapp54yy5YtsxqTkJBgunfvbjw9PY2Xl5d55plnzIkTJyz9qQHE2rVrrbYLDw83RYoUMa6uriYoKMhs2LDBqj8pKcm8/vrrxtvb27i5uZnGjRtbrd31zjvvmNKlSxsXFxfj5eVlWrVqlWbNLwB4UBnNiuyMMeZfvcUuB0pMTJSHh4cSEhLk7u6e3eUAAAAgG50/f17e3t5at26d6tatK+nOlKFp06bpxRdftIzLnz+/xo0bp5deesnStnz5cg0cOFDz589X2bJltXPnTlWqVEmSNG/ePHXq1Ek3b960TN378ccf1apVK928eVO5c+fOUH1LlixR69at02wzZMgQyzpX/fv316VLlyx90dHRGjx4sPbt26fcuXOrbNmymjVr1l2nAgIA8KjLaFbEGm8AAABAJiQkJEiSvLy8LG01a9bU7NmzFRoaKk9PT82ZM0c3btxQ/fr1LWPOnj2rnj17atGiRXJ1dU2z36pVq8re3l4zZsxQ165ddeXKFX377bdq3LhxhkO3CxcuKCIiQjVr1rTaZs2aNZo7d65iYmK0YMECq21u376t1q1bq2fPnvr++++VlJSkbdu2yc7OLjOXBcBDbEKHFtldAh4Cr89eev9BDyGeagoAAABkUEpKivr3769atWqpXLlylvY5c+bo1q1byp8/v5ycnNS7d28tXLhQJUqUkHRnIfuuXbuqT58+qlatWrr7DgwM1MqVK/XWW2/JyclJnp6e+v333zVnzpz71jVkyBDlyZNH+fPn14kTJ7R48WJL359//qmuXbtq5syZ6f6LfGJiohISEtSiRQsVL15cpUuXVpcuXdIsBA4AADKPO94AAACADAoLC9PevXu1ceNGq/a3335bly5d0qpVq1SgQAEtWrRI7du314YNG1S+fHl9/PHHunz5soYOHXrXfcfHx6tnz57q0qWLOnXqpMuXL2v48OFq166doqKi7nkH2qBBg9SjRw/99ttvGjVqlDp37qylS5fKzs5OPXv21HPPPWeZFvt3Xl5e6tq1q0JCQtSkSRM1btxY7du3l5+f34NdpEfcJ33WZHcJeAiETW+Y3SUAyCKs8ZYBrPEGAACAvn37avHixVq/fr0CAwMt7UePHlWJEiW0d+9elS1b1tLeuHFjlShRQtOnT1fr1q31448/WoVnycnJcnBw0PPPP6+vv/5ab7/9tiIjI7V9+3bLmN9//13+/v7asmWLnnrqqQzVmbrN5s2bFRQUJE9PT125csXSb4xRSkqKHBwc9Nlnn6l79+6SpJ07dyoyMlI//vij9uzZo6ioqAwfE/+H4A1Z4b8WvDHVFFnhYZtqyhpvAAAAQBYwxujVV1/VwoULFR0dbRW6SdK1a9ckyfJAhFQODg5KSUmRJH300UcaM2aMpe/06dMKCQnR7NmzVaNGDct+0tuHJMt+MiJ17M2bNyVJW7ZsUXJysqV/8eLFGjdunDZv3qzChQtb2itXrqzKlStr6NChCgoK0qxZswjeAAD4hwjeAAAAgHsICwvTrFmztHjxYrm5uSk+Pl6S5OHhIRcXF5UqVUolSpRQ79699cEHHyh//vxatGiRoqKitHTpnX/d//t6aXnz5pUkFS9eXEWKFJEkhYaGauLEiRo9erRlqulbb72lgIAAVa5cWZK0bds2de7cWatXr1bhwoW1detWbd++XbVr11a+fPl09OhRvf322ypevLiCgoIkSaVLl7Y69i+//CJ7e3vLGnVxcXH67LPP9PTTT6tQoUKKjY3V4cOH1blzZxtdUQAAHh08XAEAAAC4h2nTpikhIUH169eXn5+f5TV79mxJUu7cubVs2TIVLFhQLVu2VIUKFfTNN9/o66+/VvPmzTN8nIYNG2rWrFlatGiRKleurKZNm8rJyUmRkZFycXGRdOeuuNjYWN26dUuS5OrqqgULFqhRo0YqWbKkevTooQoVKmjdunVycnLK0HFdXV118OBBtW3bVk888YR69eqlsLAw9e7dO5NXCgAA/B1rvGUAa7wBAAAAyAjWeENWYI03PIwe1TXeuOMNAAAAAAAAsAHWeAMAAEC2OFCq9P0HAfdR+uCB7C4BAIC74o43AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALABgjcAAAAAAADABgjeAAAAAAAAABsgeAMAAAAAAABsgOANAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALABgjcAAAAAAADABgjeAAAAAAAAABsgeAMAAAAAAABsgOANAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALABgjcAAAAAAADABgjeAAAAAAAAABsgeAMAAAAAAABsgOANAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALABgjcAAAAAAADABgjeAAAAAAAAABsgeAMAAAAAAABsgOANAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALABgjcAAAAAAADABgjeAAAAAAAAABsgeAMAAAAAAABsgOANAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALABgjcAAAAAAADABgjeAAAAAAAAABvI1uAtPDxc1atXl5ubm7y9vdW6dWvFxsZajalfv77s7OysXn369LEac+LECYWGhsrV1VXe3t4aNGiQbt++bTUmOjpaVapUkZOTk0qUKKGZM2fa+vQAAAAAAADwCMvW4G3dunUKCwvTzz//rKioKN26dUvBwcG6evWq1biePXvqzJkzltf7779v6UtOTlZoaKiSkpK0efNmff3115o5c6aGDx9uGRMXF6fQ0FA1aNBAMTEx6t+/v1566SWtWLHiXztXAAAAAAAAPFpyZefBIyMjrd7PnDlT3t7e2rFjh+rWrWtpd3V1la+vb7r7WLlypfbv369Vq1bJx8dHlSpV0jvvvKMhQ4Zo5MiRcnR01PTp0xUYGKgJEyZIkkqXLq2NGzdq4sSJCgkJsd0JAgAAAAAA4JH1n1rjLSEhQZLk5eVl1R4REaECBQqoXLlyGjp0qK5du2bp27Jli8qXLy8fHx9LW0hIiBITE7Vv3z7LmMaNG1vtMyQkRFu2bEm3jps3byoxMdHqBQAAAAAAAGRGtt7x9lcpKSnq37+/atWqpXLlylnan3vuOQUEBKhQoULavXu3hgwZotjYWC1YsECSFB8fbxW6SbK8j4+Pv+eYxMREXb9+XS4uLlZ94eHhGjVqVJafIwAAAAAAAB4d/5ngLSwsTHv37tXGjRut2nv16mX5c/ny5eXn56dGjRrp6NGjKl68uE1qGTp0qAYOHGh5n5iYKH9/f5scCwAAAAAAAA+n/8RU0759+2rp0qVau3atihQpcs+xNWrUkCQdOXJEkuTr66uzZ89ajUl9n7ou3N3GuLu7p7nbTZKcnJzk7u5u9QIAAAAAAAAyI1uDN2OM+vbtq4ULF2rNmjUKDAy87zYxMTGSJD8/P0lSUFCQ9uzZo3PnzlnGREVFyd3dXWXKlLGMWb16tdV+oqKiFBQUlEVnAgAAAAAAAFjL1uAtLCxM3333nWbNmiU3NzfFx8crPj5e169flyQdPXpU77zzjnbs2KHjx49ryZIl6ty5s+rWrasKFSpIkoKDg1WmTBm9+OKL2rVrl1asWKFhw4YpLCxMTk5OkqQ+ffro2LFjGjx4sA4ePKipU6dqzpw5GjBgQLadOwAAAAAAAB5u2Rq8TZs2TQkJCapfv778/Pwsr9mzZ0uSHB0dtWrVKgUHB6tUqVJ6/fXX1bZtW/3444+WfTg4OGjp0qVycHBQUFCQXnjhBXXu3FmjR4+2jAkMDNRPP/2kqKgoVaxYURMmTNAXX3yhkJCQf/2cAQAAAAAA8GjI1ocrGGPu2e/v769169bddz8BAQFatmzZPcfUr19fO3fuzFR9AAAAAAAAwIP6TzxcAQAAAAAAAHjYELwBAAAAAAAANkDwBgAAAAAAANgAwRsAAAAAAABgAwRvAAAAAAAAgA0QvAEAAAAAAAA2QPAGAAAAAAAA2ADBGwAAAAAAAGADBG8AAAAAAACADRC8AQAAAAAAADZA8AYAAAAAAADYAMEbAAAAAAAAYAMEbwAAAAAAAIANELwBAAAAAAAANkDwBgAAAAAAANgAwRsAAAAAAABgAwRvAAAAAAAAgA0QvAEAAAAAAAA2QPAGAAAAAAAA2ADBGwAAAAAAAGADBG8AACBLhIeHq3r16nJzc5O3t7dat26t2NhYqzG9e/dW8eLF5eLiooIFC6pVq1Y6ePCg1ZgTJ04oNDRUrq6u8vb21qBBg3T79m1Lf3R0tOzs7NK84uPj71pbdHS0WrVqJT8/P+XJk0eVKlVSREREmnGXLl1SWFiY/Pz85OTkpCeeeELLli37h1cGAAAAj6pc2V0AAAB4OKxbt05hYWGqXr26bt++rbfeekvBwcHav3+/8uTJI0mqWrWqnn/+eRUtWlQXLlzQyJEjFRwcrLi4ODk4OCg5OVmhoaHy9fXV5s2bdebMGXXu3Fm5c+fW2LFjrY4XGxsrd3d3y3tvb++71rZ582ZVqFBBQ4YMkY+Pj5YuXarOnTvLw8NDLVq0kCQlJSWpSZMm8vb21rx581S4cGH99ttv8vT0zPqLBQAAgEeCnTHGZHcR/3WJiYny8PBQQkKC1V/wAQDA3Z0/f17e3t5at26d6tatm+6Y3bt3q2LFijpy5IiKFy+u5cuXq0WLFjp9+rR8fHwkSdOnT9eQIUN0/vx5OTo6Kjo6Wg0aNNDFixf/USgWGhoqHx8fffXVV5bjjB8/XgcPHlTu3LnT3WbevHkaNWqUjhw5IldXV1WuXFmLFy+2BIvInAOlSmd3CXgIlD54ILtLsPJJnzXZXQIeAmHTG2Z3CVYmdGiR3SXgIfD67KXZXUKWymhWxFRTAABgEwkJCZIkLy+vdPuvXr2qGTNmKDAwUP7+/pKkLVu2qHz58pbQTZJCQkKUmJioffv2WW1fqVIl+fn5qUmTJtq0adMD1ffX2pYsWaKgoCCFhYXJx8dH5cqV09ixY5WcnCxJOnPmjDp16qTu3bvrwIEDio6OVps2bcS/YQIAAOBumGoKAACyXEpKivr3769atWqpXLlyVn1Tp07V4MGDdfXqVZUsWVJRUVFydHSUJMXHx1uFbpIs71PXcPPz89P06dNVrVo13bx5U1988YXq16+vrVu3qkqVKhmqb86cOdq+fbs+/fRTS9uxY8e0Zs0aPf/881q2bJmOHDmiV155Rbdu3dKIESN05swZ3b59W23atFFAQIAkqXz58g92gQAAAPBIIHgDAABZLiwsTHv37tXGjRvT9D3//PNq0qSJzpw5ow8++EDt27fXpk2b5OzsnKF9lyxZUiVLlrS8r1mzpo4ePaqJEyfq22+/ve/2a9euVbdu3fT555+rbNmylvaUlBR5e3vrs88+k4ODg6pWrapTp05p/PjxGjFihCpWrKhGjRqpfPnyCgkJUXBwsNq1a6d8+fJlqG4AAAA8ephqCgAAslTfvn21dOlSrV27VkWKFEnT7+Hhoccff1x169bVvHnzdPDgQS1cuFCS5Ovrq7Nnz1qNT33v6+t712M++eSTOnLkyH1rW7dunVq2bKmJEyeqc+fOVn1+fn564okn5ODgYGkrXbq04uPjlZSUJAcHB0VFRWn58uUqU6aMPv74Y5UsWVJxcXH3PS4AAAAeTQRvAAAgSxhj1LdvXy1cuFBr1qxRYGBghrYxxujmzZuSpKCgIO3Zs0fnzp2zjImKipK7u7vKlClz1/3ExMTIz8/vnseKjo5WaGioxo0bp169eqXpr1Wrlo4cOaKUlBRL26FDh+Tn52eZCmtnZ6datWpp1KhR2rlzpxwdHS2hIQAAAPB3TDUFAABZIiwsTLNmzdLixYvl5uZmWZPNw8NDLi4uOnbsmGbPnq3g4GAVLFhQv//+u9577z25uLioefPmkqTg4GCVKVNGL774ot5//33Fx8dr2LBhCgsLk5OTkyRp0qRJCgwMVNmyZXXjxg198cUXWrNmjVauXGmpZcqUKVq4cKFWr14t6c700hYtWui1115T27ZtLbU5OjpaHrDw8ssva8qUKXrttdf06quv6vDhwxo7dqz69esnSdq6datWr16t4OBgeXt7a+vWrTp//rxKl+bJnAAAAEgfwRsAAMgS06ZNkyTVr1/fqn3GjBnq2rWrnJ2dtWHDBk2aNEkXL16Uj4+P6tatq82bN8vb21uS5ODgoKVLl+rll19WUFCQ8uTJoy5dumj06NGW/SUlJen111/XqVOn5OrqqgoVKmjVqlVq0KCBZcwff/yho0ePWt5//fXXunbtmsLDwxUeHm5pr1evnqKjoyVJ/v7+WrFihQYMGKAKFSqocOHCeu211zRkyBBJkru7u9avX69JkyYpMTFRAQEBmjBhgpo1a5al1xEAAAAPDztjjMnuIv7rEhMT5eHhoYSEBLm7u2d3OQAAAA+FA6W4WxD/XOmDB7K7BCuf9FmT3SXgIRA2vWF2l2BlQocW2V0CHgKvz16a3SVkqYxmRazxBgAAAAAAANgAwRsAZIPw8HBVr15dbm5u8vb2VuvWrRUbG2vpv3Dhgl599VWVLFlSLi4uKlq0qPr166eEhIR09/fnn3+qSJEisrOz06VLlyztXbt2lZ2dXZpX2bJl71pbbGysGjRoIB8fHzk7O+uxxx7TsGHDdOvWLatxkyZNstTn7++vAQMG6MaNG//swgAAAADAQ4Q13gAgG6xbt05hYWGqXr26bt++rbfeekvBwcHav3+/8uTJo9OnT+v06dP64IMPVKZMGf3222/q06ePTp8+rXnz5qXZX48ePVShQgWdOnXKqn3y5Ml67733LO9v376tihUr6tlnn71rbblz51bnzp1VpUoVeXp6ateuXerZs6dSUlI0duxYSdKsWbP05ptv6quvvlLNmjV16NAhS8j34YcfZtFVwl+V/7p8dpeAHG5Plz3ZXQIAAMAjh+ANALJBZGSk1fuZM2fK29tbO3bsUN26dVWuXDnNnz/f0l+8eHG9++67euGFF3T79m3lyvV/X9/Tpk3TpUuXNHz4cC1fvtxqvx4eHvLw8LC8X7RokS5evKhu3brdtbbHHntMjz32mOV9QECAoqOjtWHDBkvb5s2bVatWLT333HOSpGLFiqlTp07aunWrZcy8efM0atQoHTlyRK6urqpcubIWL16sPHnyZPQyAQAAAECOxlRT/OdlxZS8Xbt2qVOnTvL395eLi4tKly6tyZMnpzlWRESEKlasKFdXV/n5+al79+76888/71nf6tWrVbNmTbm5ucnX11dDhgzR7du3Lf3R0dFq1aqV/Pz8lCdPHlWqVEkRERFZcGXwMEn9vHp5ed1zjLu7u1Xotn//fo0ePVrffPON7O3v/5X+5ZdfqnHjxgoICMhwbUeOHFFkZKTq1atnaatZs6Z27Nihbdu2SZKOHTumZcuWqXnz5pKkM2fOqFOnTurevbsOHDig6OhotWnTRjzPBwAAAMCjhOAN/3mpU/J+/vlnRUVF6datWwoODtbVq1clyWpK3t69ezVz5kxFRkaqR48eln3s2LFD3t7e+u6777Rv3z7973//09ChQzVlyhTLmE2bNqlz587q0aOH9u3bp7lz52rbtm3q2bPnXWvbtWuXmjdvrqZNm2rnzp2aPXu2lixZojfffNMyZvPmzapQoYLmz5+v3bt3q1u3burcubOWLn24nuiCB5eSkqL+/furVq1aKleuXLpj/vjjD73zzjvq1auXpe3mzZvq1KmTxo8fr6JFi973OKdPn9by5cv10ksvZaiumjVrytnZWY8//rjq1Kmj0aNHW/qee+45jR49WrVr11bu3LlVvHhx1a9fX2+99ZakO8Hb7du31aZNGxUrVkzly5fXK6+8orx582bo2AAAAADwMLAz3H5wXxl9RCz+HefPn5e3t7fWrVununXrpjtm7ty5euGFF3T16lWru4P+KiwsTAcOHNCaNXce+f7BBx9o2rRpOnr0qGXMxx9/rHHjxun3339Pdx9vvfWWoqKitH37dkvbjz/+qPbt2+vcuXNyc3NLd7vQ0FD5+Pjoq6++knTnrrjBgwdr3759yp07t8qWLatZs2Zl6q4k5Fwvv/yyli9fro0bN6pIkSJp+hMTE9WkSRN5eXlpyZIlyp07tyRp4MCBOn36tH744QdJdz5HDRo00MWLF+Xp6ZlmP+Hh4ZowYYJOnz4tR0fH+9Z18uRJXb58Wbt27dKgQYPUr18/DR482HKsjh07asyYMapRo4aOHDmi1157TT179tTbb7+t5ORkhYSEaNu2bQoJCVFwcLDatWunfPny/YMr9WhjjTf8U//FNd4OlCqd3SXgIVD64IHsLsHKJ33WZHcJeAiETW+Y3SVYmdChRXaXgIfA67MfrptPMpoVcccbcpwHnZKX3pi/7iMoKEgnT57UsmXLZIzR2bNnNW/ePMvUufTcvHlTzs7OVm0uLi66ceOGduzYkaFj3759W61bt1a9evW0e/dubdmyRb169ZKdnd1dt8fDo2/fvlq6dKnWrl2bbuh2+fJlNW3aVG5ublq4cKEldJOkNWvWaO7cucqVK5dy5cqlRo0aSZIKFCigESNGWO3HGKOvvvpKL774YoZCN0ny9/dXmTJl1KlTJ7333nsaOXKkkpOTJUlvv/22XnzxRb300ksqX768nnnmGY0dO1bh4eFKSUmRg4ODoqKitHz5cpUpU0Yff/yxSpYsqbi4uAe9VAAAAACQ4xC8IUd50Cl5f7d582bNnj3bakytWrUUERGhDh06yNHRUb6+vvLw8NAnn3xy1/2EhIRo8+bN+v7775WcnKxTp05ZpuOdOXMm3W3mzJmj7du3Wxa3T0xMVEJCglq0aKHixYurdOnS6tKlS4amDiLnMsaob9++WrhwodasWaPAwMA0YxITExUcHCxHR0ctWbIkTcg7f/587dq1SzExMYqJidEXX3whSdqwYYPCwsKsxq5bt05HjhyxmoKdGSkpKbp165ZSUlIkSdeuXUuzppyDg4Pl3CTJzs5OtWrV0qhRo7Rz5045Ojpq4cKFD3R8AAAAAMiJeKopcpSwsDDt3btXGzduTLc/MTFRoaGhKlOmjEaOHJnumL1796pVq1YaMWKEgoODLe379+/Xa6+9puHDhyskJERnzpzRoEGD1KdPH3355Zfp7is4OFjjx49Xnz599OKLL8rJyUlvv/22NmzYkO5C92vXrlW3bt30+eefq2zZspLu3LnXtWtXhYSEqEmTJmrcuLHat28vPz+/TF4d5CRhYWGaNWuWFi9eLDc3N8XHx0u68xRSFxcXS+h27do1fffdd0pMTFRiYqIkqWDBgnJwcFDx4sWt9vnHH39IkkqXLp1mqumXX36pGjVqpBtYT5kyRQsXLtTq1asl3XnISO7cuVW+fHk5OTnpl19+0dChQ9WhQwfLHXctW7bUhx9+qMqVK1ummr799ttq2bKlHBwctHXrVq1evVrBwcHy9vbW1q1bdf78eZUuzbQyAAAAAI8OgjfkGKlT8tavX5/pKXmp9u/fr0aNGqlXr14aNmyYVV94eLhq1aqlQYMGSZIqVKigPHnyqE6dOhozZsxdg7CBAwdqwIABOnPmjPLly6fjx49r6NCheuyxx6zGrVu3Ti1bttTEiRPVuXNnq74ZM2aoX79+ioyM1OzZszVs2DBFRUXpqaeeytQ1Qs4xbdo0SVL9+vWt2mfMmKGuXbvq119/1datWyVJJUqUsBoTFxenYsWKZfhYCQkJmj9/frpP8pXuBHZ/XdswV65cGjdunA4dOiRjjAICAtS3b18NGDDAMmbYsGGys7PTsGHDdOrUKRUsWFAtW7bUu+++K0lyd3fX+vXrNWnSJCUmJiogIEATJkxQs2bNMlw3AAAAAOR0PFwhA3i4QvYyxujVV1/VwoULFR0drccffzzNmMTERIWEhMjJyUnLli2Tq6trmjH79u1Tw4YN1aVLF73//vtp+tu2batcuXJp9uzZlrYtW7aoZs2aOnXqlAoVKpSheocPH66ZM2cqLi7OMvUuOjpaLVq00Lhx49JMAUxPUFCQqlevro8++ihDxwTw8OPhCvineLgCHlY8XAEPIx6ugIcRD1cA/qPCwsL03XffadasWZYpefHx8bp+/bqk/1sH6+rVq/ryyy+VmJhoGZO6EPzevXvVoEEDBQcHa+DAgZb+8+fPW47TsmVLLViwQNOmTdOxY8e0adMm9evXT08++aQldFu4cKFKlSplVd/48eO1Z88e7du3T++8847ee+89ffTRR5bQbe3atQoNDVW/fv3Utm1by7EvXLgg6c7dS0OHDtWWLVv022+/aeXKlTp8+DBT8gAAAAAAyOGYaor/vKyYkjdv3jydP39e3333nb777jtLf0BAgI4fPy5J6tq1qy5fvqwpU6bo9ddfl6enpxo2bKhx48ZZxickJCg2NtbqGMuXL9e7776rmzdvqmLFilq8eLHVdLqvv/5a165dU3h4uMLDwy3t9erVU3R0tFxdXXXw4EF9/fXX+vPPP+Xn56ewsDD17t37wS/ao2ykR3ZXgIfByITsrgAAAADAQ4CpphnAVFMgByF4Q1b4DwZvTDXFP8VUUzysmGqKhxFTTfEwYqopAAAAAAAAgCxD8AYAAAAAAADYAGu8PcKKvflTdpeAh8Dx90KzuwQAAAAAAP6TuOMNAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALABgjcAAAAAAADABgjeAAAAAAAAABsgeAMAAAAAAABsgOANAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALABgjcAAAAAAADABgjeAAAAAAAAABsgeAMAAAAAAABsgOANAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALABgjcAAAAAAADABgjeAAAAAAAAABsgeAMAAAAAAABsgOANAAAAAAAAsAGCNwAAAAAAAMAGCN4AAAAAAAAAGyB4AwAAAAAAAGyA4A0AAAAAAACwgWwN3sLDw1W9enW5ubnJ29tbrVu3VmxsrNWYGzduKCwsTPnz51fevHnVtm1bnT171mrMiRMnFBoaKldXV3l7e2vQoEG6ffu21Zjo6GhVqVJFTk5OKlGihGbOnGnr0wMAAAAAAMAjLFuDt3Xr1iksLEw///yzoqKidOvWLQUHB+vq1auWMQMGDNCPP/6ouXPnat26dTp9+rTatGlj6U9OTlZoaKiSkpK0efNmff3115o5c6aGDx9uGRMXF6fQ0FA1aNBAMTEx6t+/v1566SWtWLHiXz1fAAAAAAAAPDpyZefBIyMjrd7PnDlT3t7e2rFjh+rWrauEhAR9+eWXmjVrlho2bChJmjFjhkqXLq2ff/5ZTz31lFauXKn9+/dr1apV8vHxUaVKlfTOO+9oyJAhGjlypBwdHTV9+nQFBgZqwoQJkqTSpUtr48aNmjhxokJCQv718wYAAAAAAMDD7z+1xltCQoIkycvLS5K0Y8cO3bp1S40bN7aMKVWqlIoWLaotW7ZIkrZs2aLy5cvLx8fHMiYkJESJiYnat2+fZcxf95E6JnUff3fz5k0lJiZavQAAAAAAAIDM+M8EbykpKerfv79q1aqlcuXKSZLi4+Pl6OgoT09Pq7E+Pj6Kj4+3jPlr6Jban9p3rzGJiYm6fv16mlrCw8Pl4eFhefn7+2fJOQIAAAAAAODR8Z8J3sLCwrR371798MMP2V2Khg4dqoSEBMvr5MmT2V0SAAAAAAAAcpgHWuPtxIkT+u2333Tt2jUVLFhQZcuWlZOT0wMX0bdvXy1dulTr169XkSJFLO2+vr5KSkrSpUuXrO56O3v2rHx9fS1jtm3bZrW/1Kee/nXM35+EevbsWbm7u8vFxSVNPU5OTv/ofAAAAAAAAIAM3/F2/PhxDRkyRAEBAQoMDFS9evXUrFkzVatWTR4eHmrSpInmzp2rlJSUDB/cGKO+fftq4cKFWrNmjQIDA636q1atqty5c2v16tWWttjYWJ04cUJBQUGSpKCgIO3Zs0fnzp2zjImKipK7u7vKlCljGfPXfaSOSd0HAAAAAAAAkNUyFLz169dPFStWVFxcnMaMGaP9+/crISFBSUlJio+P17Jly1S7dm0NHz5cFSpU0Pbt2zN08LCwMH333XeaNWuW3NzcFB8fr/j4eMu6ax4eHurRo4cGDhyotWvXaseOHerWrZuCgoL01FNPSZKCg4NVpkwZvfjii9q1a5dWrFihYcOGKSwszHLXWp8+fXTs2DENHjxYBw8e1NSpUzVnzhwNGDDgQa4ZAAAAAAAAcF8ZmmqaJ08eHTt2TPnz50/T5+3trYYNG6phw4YaMWKEIiMjdfLkSVWvXv2++502bZokqX79+lbtM2bMUNeuXSVJEydOlL29vdq2baubN28qJCREU6dOtYx1cHDQ0qVL9fLLLysoKEh58uRRly5dNHr0aMuYwMBA/fTTTxowYIAmT56sIkWK6IsvvlBISEhGTh8AAAAAAADItAwFb+Hh4RneYdOmTTM81hhz3zHOzs765JNP9Mknn9x1TEBAgJYtW3bP/dSvX187d+7McG0AAAAAAADAP5Hpp5rGxcXp8OHDadoPHz6s48ePZ0VNAAAAAAAAQI6X6eCta9eu2rx5c5r2rVu3WqaHAgAAAAAAAI+6TAdvO3fuVK1atdK0P/XUU4qJicmKmgAAAAAAAIAcL9PBm52dnS5fvpymPSEhQcnJyVlSFAAAAAAAAJDTZTp4q1u3rsLDw61CtuTkZIWHh6t27dpZWhwAAAAAAACQU2XoqaZ/NW7cONWtW1clS5ZUnTp1JEkbNmxQYmKi1qxZk+UFAgAAAAAAADlRpu94K1OmjHbv3q327dvr3Llzunz5sjp37qyDBw+qXLlytqgRAAAAAAAAyHEyfcebJBUqVEhjx47N6loAAAAAAACAh0am73iT7kwtfeGFF1SzZk2dOnVKkvTtt99q48aNWVocAAAAAAAAkFNlOnibP3++QkJC5OLiol9//VU3b96UdOepptwFBwAAAAAAANyR6eBtzJgxmj59uj7//HPlzp3b0l6rVi39+uuvWVocAAAAAAAAkFNlOniLjY1V3bp107R7eHjo0qVLWVETAAAAAAAAkONlOnjz9fXVkSNH0rRv3LhRjz32WJYUBQAAAAAAAOR0mQ7eevbsqddee01bt26VnZ2dTp8+rYiICL3xxht6+eWXbVEjAAAAAAAAkOPkyuwGb775plJSUtSoUSNdu3ZNdevWlZOTk9544w29+uqrtqgRAAAAAAAAyHEyHbzZ2dnpf//7nwYNGqQjR47oypUrKlOmjPLmzWuL+gAAAAAAAIAcKdNTTVM5OjqqTJkyKlWqlFatWqUDBw5kZV0AAAAAAABAjpbp4K19+/aaMmWKJOn69euqXr262rdvrwoVKmj+/PlZXiAAAAAAAACQE2U6eFu/fr3q1KkjSVq4cKFSUlJ06dIlffTRRxozZkyWFwgAAAAAAADkRJkO3hISEuTl5SVJioyMVNu2beXq6qrQ0FAdPnw4ywsEAAAAAAAAcqJMB2/+/v7asmWLrl69qsjISAUHB0uSLl68KGdn5ywvEAAAAAAAAMiJMv1U0/79++v5559X3rx5FRAQoPr160u6MwW1fPnyWV0fAAAAAAAAkCNlOnh75ZVXVKNGDZ04cUJNmjSRvf2dm+Yee+wx1ngDAAAAAAAA/r9MB2+SVLVqVVWtWtWqLTQ0NEsKAgAAAAAAAB4GGVrj7b333tP169cztMOtW7fqp59++kdFAQAAAAAAADldhoK3/fv3q2jRonrllVe0fPlynT9/3tJ3+/Zt7d69W1OnTlXNmjXVoUMHubm52axgAAAAAAAAICfI0FTTb775Rrt27dKUKVP03HPPKTExUQ4ODnJyctK1a9ckSZUrV9ZLL72krl278nRTAAAAAAAAPPIyvMZbxYoV9fnnn+vTTz/V7t279dtvv+n69esqUKCAKlWqpAIFCtiyTgAAAAAAACBHyfTDFezt7VWpUiVVqlTJBuUAAAAAAAAAD4cMrfEGAAAAAAAAIHMI3gAAAAAAAAAbIHgDAAAAAAAAbIDgDQAAAAAAALCBfxy8JSYmatGiRTpw4EBW1AMAAAAAAAA8FDIdvLVv315TpkyRJF2/fl3VqlVT+/btVaFCBc2fPz/LCwQAAAAAAAByokwHb+vXr1edOnUkSQsXLpQxRpcuXdJHH32kMWPGZHmBAAAAAAAAQE6U6eAtISFBXl5ekqTIyEi1bdtWrq6uCg0N1eHDh7O8QAAAAAAAACAnynTw5u/vry1btujq1auKjIxUcHCwJOnixYtydnbO8gIBAAAAAACAnChXZjfo37+/nn/+eeXNm1cBAQGqX7++pDtTUMuXL5/V9QEAAAAAAAA5UqaDt1deeUVPPvmkTp48qSZNmsje/s5Nc4899hhrvAEAAAAAAAD/X6aDN0mqVq2aqlWrJklKTk7Wnj17VLNmTeXLly9LiwMAAAAAAAByqkyv8da/f399+eWXku6EbvXq1VOVKlXk7++v6OjorK4PAAAAAAAAyJEyHbzNmzdPFStWlCT9+OOPiouL08GDBzVgwAD973//y/ICAQAAAAAAgJwo08HbH3/8IV9fX0nSsmXL9Oyzz+qJJ55Q9+7dtWfPniwvEAAAAAAAAMiJMh28+fj4aP/+/UpOTlZkZKSaNGkiSbp27ZocHByyvEAAAAAAAAAgJ8r0wxW6deum9u3by8/PT3Z2dmrcuLEkaevWrSpVqlSWFwgAAAAAAADkRJkO3kaOHKly5crp5MmTevbZZ+Xk5CRJcnBw0JtvvpnlBQIAAAAAAAA5UaaDN0lq165dmrYuXbr842IAAAAAAACAh0Wm13iTpHXr1qlly5YqUaKESpQooaefflobNmzI6toAAAAAAACAHCvTwdt3332nxo0by9XVVf369VO/fv3k4uKiRo0aadasWbaoEQAAAAAAAMhxMj3V9N1339X777+vAQMGWNr69eunDz/8UO+8846ee+65LC0QAAAAAAAAyIkyfcfbsWPH1LJlyzTtTz/9tOLi4rKkKAAAAAAAACCny3Tw5u/vr9WrV6dpX7Vqlfz9/bOkKAAAAAAAACCny/RU09dff139+vVTTEyMatasKUnatGmTZs6cqcmTJ2d5gQAAAAAAAEBOlOng7eWXX5avr68mTJigOXPmSJJKly6t2bNnq1WrVlleIAAAAAAAAJATZTp4k6RnnnlGzzzzTFbXAgAAAAAAADw0Mr3GGwAAAAAAAID7y9Adb/ny5ZOdnV2GdnjhwoV/VBAAAAAAAADwMMhQ8DZp0iQblwEAAAAAAAA8XDIUvHXp0sXWdQAAAAAAAAAPFdZ4AwAAAAAAAGyA4A0AAAAAAACwAYI3AAAAAAAAwAYI3gAAAAAAAAAbIHgDAAAAAAAAbCBDTzVt06ZNhne4YMGCBy4GAAAAAAAAeFhkKHjz8PCwdR0AAAAAAADAQyVDwduMGTNsXQcAAAAAAADwUGGNNwAAAAAAAMAGMnTH29/NmzdPc+bM0YkTJ5SUlGTV9+uvv2ZJYQAAAAAAAEBOluk73j766CN169ZNPj4+2rlzp5588knlz59fx44dU7NmzWxRIwAAAAAAAJDjZDp4mzp1qj777DN9/PHHcnR01ODBgxUVFaV+/fopISHBFjUCAAAAAAAAOU6mg7cTJ06oZs2akiQXFxddvnxZkvTiiy/q+++/z9rqAAAAAAAAgBwq08Gbr6+vLly4IEkqWrSofv75Z0lSXFycjDFZWx0AAAAAAACQQ2U6eGvYsKGWLFkiSerWrZsGDBigJk2aqEOHDnrmmWeyvEAAAAAAAAAgJ8r0U00/++wzpaSkSJLCwsKUP39+bd68WU8//bR69+6d5QUCAAAAAAAAOVGmgzd7e3vZ2//fjXIdO3ZUx44ds7QoAAAAAAAAIKfL9FTTEiVKaOTIkTp06JAt6gEAAAAAAAAeCpkO3sLCwvTTTz+pdOnSql69uiZPnqz4+Hhb1AYAAAAAAADkWJkO3gYMGKDt27frwIEDat68uT755BP5+/srODhY33zzjS1qBAAAAAAAAHKcTAdvqZ544gmNGjVKhw4d0oYNG3T+/Hl169YtK2sDAAAAAAAAcqxMP1zhr7Zt26ZZs2Zp9uzZSkxM1LPPPptVdQEAAAAAAAA5WqaDt0OHDikiIkLff/+94uLi1LBhQ40bN05t2rRR3rx5bVEjAAAAAAAAkONkOngrVaqUqlevrrCwMHXs2FE+Pj62qAsAAAAAAADI0TIdvMXGxurxxx+3RS0AAAAAAADAQyPTD1cgdAMAAAAAAADu74GfagoAAAAAAADg7gjeAAAAAAAAABsgeAMAAAAAAABsINPB2+jRo3Xt2rU07devX9fo0aOzpCgAAAAAAAAgp8t08DZq1ChduXIlTfu1a9c0atSoLCkKAAAAAAAAyOkyHbwZY2RnZ5emfdeuXfLy8srUvtavX6+WLVuqUKFCsrOz06JFi6z6u3btKjs7O6tX06ZNrcZcuHBBzz//vNzd3eXp6akePXqkCQZ3796tOnXqyNnZWf7+/nr//fczVScAAAAAAACQWbkyOjBfvnyW8OuJJ56wCt+Sk5N15coV9enTJ1MHv3r1qipWrKju3burTZs26Y5p2rSpZsyYYXnv5ORk1f/888/rzJkzioqK0q1bt9StWzf16tVLs2bNkiQlJiYqODhYjRs31vTp07Vnzx51795dnp6e6tWrV6bqBQAAAAAAADIqw8HbpEmTZIxR9+7dNWrUKHl4eFj6HB0dVaxYMQUFBWXq4M2aNVOzZs3uOcbJyUm+vr7p9h04cECRkZHavn27qlWrJkn6+OOP1bx5c33wwQcqVKiQIiIilJSUpK+++kqOjo4qW7asYmJi9OGHHxK8AQAAAAAAwGYyHLx16dJFkhQYGKhatWopV64Mb/qPREdHy9vbW/ny5VPDhg01ZswY5c+fX5K0ZcsWeXp6WkI3SWrcuLHs7e21detWPfPMM9qyZYvq1q0rR0dHy5iQkBCNGzdOFy9eVL58+dIc8+bNm7p586blfWJiog3PEAAAAAAAAA+jTK/x5ubmpgMHDljeL168WK1bt9Zbb72lpKSkLC2uadOm+uabb7R69WqNGzdO69atU7NmzZScnCxJio+Pl7e3t9U2uXLlkpeXl+Lj4y1jfHx8rMakvk8d83fh4eHy8PCwvPz9/bP0vAAAAAAAAPDwy3Tw1rt3bx06dEiSdOzYMXXo0EGurq6aO3euBg8enKXFdezYUU8//bTKly+v1q1ba+nSpdq+fbuio6Oz9Dh/N3ToUCUkJFheJ0+etOnxAAAAAAAA8PDJdPB26NAhVapUSZI0d+5c1atXT7NmzdLMmTM1f/78rK7PymOPPaYCBQroyJEjkiRfX1+dO3fOaszt27d14cIFy7pwvr6+Onv2rNWY1Pd3WzvOyclJ7u7uVi8AAAAAAAAgMzIdvBljlJKSIklatWqVmjdvLkny9/fXH3/8kbXV/c3vv/+uP//8U35+fpKkoKAgXbp0STt27LCMWbNmjVJSUlSjRg3LmPXr1+vWrVuWMVFRUSpZsmS667sBAAAAAAAAWSHTwVu1atU0ZswYffvtt1q3bp1CQ0MlSXFxcWnWUrufK1euKCYmRjExMZZ9xMTE6MSJE7py5YoGDRqkn3/+WcePH9fq1avVqlUrlShRQiEhIZKk0qVLq2nTpurZs6e2bdumTZs2qW/fvurYsaMKFSokSXruuefk6OioHj16aN++fZo9e7YmT56sgQMHZvbUAQAAAAAAgAzLdPA2adIk/frrr+rbt6/+97//qUSJEpKkefPmqWbNmpna1y+//KLKlSurcuXKkqSBAweqcuXKGj58uBwcHLR79249/fTTeuKJJ9SjRw9VrVpVGzZskJOTk2UfERERKlWqlBo1aqTmzZurdu3a+uyzzyz9Hh4eWrlypeLi4lS1alW9/vrrGj58uHr16pXZUwcAAAAAAAAyLFdmN6hQoYL27NmTpn38+PFycHDI1L7q168vY8xd+1esWHHffXh5eWnWrFn3HFOhQgVt2LAhU7UBAAAAAAAA/0Sm73iTpEuXLumLL77Q0KFDdeHCBUnS/v370zzoAAAAAAAAAHhUZfqOt927d6tRo0by9PTU8ePH1bNnT3l5eWnBggU6ceKEvvnmG1vUCQAAAAAAAOQomb7jbeDAgerWrZsOHz4sZ2dnS3vz5s21fv36LC0OAAAAAAAAyKkyHbxt375dvXv3TtNeuHBhxcfHZ0lRAAAAAAAAQE6X6eDNyclJiYmJadoPHTqkggULZklRAAAAAAAAQE6X6eDt6aef1ujRo3Xr1i1Jkp2dnU6cOKEhQ4aobdu2WV4gAAAAAAAAkBNlOnibMGGCrly5Im9vb12/fl316tVTiRIl5ObmpnfffdcWNQIAAAAAAAA5Tqafaurh4aGoqCht3LhRu3fv1pUrV1SlShU1btzYFvUBAAAAAAAAOVKmg7dUtWvXVu3atbOyFgAAAAAAAOChkempppK0evVqtWjRQsWLF1fx4sXVokULrVq1KqtrAwAAAAAAAHKsTAdvU6dOVdOmTeXm5qbXXntNr732mtzd3dW8eXN98skntqgRAAAAAAAAyHEyPdV07Nixmjhxovr27Wtp69evn2rVqqWxY8cqLCwsSwsEAAAAAAAAcqJM3/F26dIlNW3aNE17cHCwEhISsqQoAAAAAAAAIKfLdPD29NNPa+HChWnaFy9erBYtWmRJUQAAAAAAAEBOl6Gpph999JHlz2XKlNG7776r6OhoBQUFSZJ+/vlnbdq0Sa+//rptqgQAAAAAAABymAwFbxMnTrR6ny9fPu3fv1/79++3tHl6euqrr77SsGHDsrZCAAAAAAAAIAfKUPAWFxdn6zoAAAAAAACAh0qm13gDAAAAAAAAcH8EbwAAAAAAAIANELwBAAAAAAAANkDwBgAAAAAAANgAwRsAAAAAAABgAxl6qunu3bszvMMKFSo8cDEAAAAAAADAwyJDwVulSpVkZ2cnY0y6/al9dnZ2Sk5OztICAQAAAAAAgJwoQ8FbXFycresAAAAAAAAAHioZCt4CAgJsXQcAAAAAAADwUMlQ8LZkyRI1a9ZMuXPn1pIlS+459umnn86SwgAAAAAAAICcLEPBW+vWrRUfHy9vb2+1bt36ruNY4w0AAAAAAAC4I0PBW0pKSrp/BgAAAAAAAJA++8xu8M033+jmzZtp2pOSkvTNN99kSVEAAAAAAABATpfp4K1bt25KSEhI03758mV169YtS4oCAAAAAAAAcrpMB2/GGNnZ2aVp//333+Xh4ZElRQEAAAAAAAA5XYbWeJOkypUry87OTnZ2dmrUqJFy5fq/TZOTkxUXF6emTZvapEgAAAAAAAAgp8lw8Jb6NNOYmBiFhIQob968lj5HR0cVK1ZMbdu2zfICAQAAAAAAgJwow8HbiBEjJEnFihVThw4d5OzsbLOiAAAAAAAAgJwuw8Fbqi5duki68xTTc+fOKSUlxaq/aNGiWVMZAAAAAAAAkINlOng7fPiwunfvrs2bN1u1pz50ITk5OcuKAwAAAAAAAHKqTAdvXbt2Va5cubR06VL5+fml+4RTAAAAAAAA4FGX6eAtJiZGO3bsUKlSpWxRDwAAAAAAAPBQsM/sBmXKlNEff/xhi1oAAAAAAACAh0amg7dx48Zp8ODBio6O1p9//qnExESrFwAAAAAAAIAHmGrauHFjSVKjRo2s2nm4AgAAAAAAAPB/Mh28rV271hZ1AAAAAAAAAA+VTAdv9erVs0UdAAAAAAAAwEMl08Hb+vXr79lft27dBy4GAAAAAAAAeFhkOnirX79+mjY7OzvLn1njDQAAAAAAAHiAp5pevHjR6nXu3DlFRkaqevXqWrlypS1qBAAAAAAAAHKcTN/x5uHhkaatSZMmcnR01MCBA7Vjx44sKQwAAAAAAADIyTJ9x9vd+Pj4KDY2Nqt2BwAAAAAAAORomb7jbffu3VbvjTE6c+aM3nvvPVWqVCmr6gIAAAAAAABytEwHb5UqVZKdnZ2MMVbtTz31lL766qssKwwAAAAAAADIyTIdvMXFxVm9t7e3V8GCBeXs7JxlRQEAAAAAAAA5XaaDt4CAAFvUAQAAAAAAADxUsuzhCgAAAAAAAAD+D8EbAAAAAAAAYAMEbwAAAAAAAIANELwBAAAAAAAANvBAwdvRo0c1bNgwderUSefOnZMkLV++XPv27cvS4gAAAAAAAICcKtPB27p161S+fHlt3bpVCxYs0JUrVyRJu3bt0ogRI7K8QAAAAAAAACAnynTw9uabb2rMmDGKioqSo6Ojpb1hw4b6+eefs7Q4AAAAAAAAIKfKdPC2Z88ePfPMM2navb299ccff2RJUQAAAAAAAEBOl+ngzdPTU2fOnEnTvnPnThUuXDhLigIAAAAAAAByukwHbx07dtSQIUMUHx8vOzs7paSkaNOmTXrjjTfUuXNnW9QIAAAAAAAA5DiZDt7Gjh2rUqVKyd/fX1euXFGZMmVUt25d1axZU8OGDbNFjQAAAAAAAECOkyuzGzg6Ourzzz/X22+/rb179+rKlSuqXLmyHn/8cVvUBwAAAAAAAORImQ7eUhUtWlRFixbNyloAAAAAAACAh0amgzdjjObNm6e1a9fq3LlzSklJsepfsGBBlhUHAAAAAAAA5FSZDt769++vTz/9VA0aNJCPj4/s7OxsURcAAAAAAACQo2U6ePv222+1YMECNW/e3Bb1AAAAAAAAAA+FTD/V1MPDQ4899pgtagEAAAAAAAAeGpkO3kaOHKlRo0bp+vXrtqgHAAAAAAAAeChkeqpp+/bt9f3338vb21vFihVT7ty5rfp//fXXLCsOAAAAAAAAyKkyHbx16dJFO3bs0AsvvMDDFQAAAAAAAIC7yHTw9tNPP2nFihWqXbu2LeoBAAAAAAAAHgqZXuPN399f7u7utqgFAAAAAAAAeGhkOnibMGGCBg8erOPHj9ugHAAAAAAAAODhkOmppi+88IKuXbum4sWLy9XVNc3DFS5cuJBlxQEAAAAAAAA5VaaDt0mTJtmgDAAAAAAAAODh8kBPNQUAAAAAAABwbxkK3hITEy0PVEhMTLznWB68AAAAAAAAAGQweMuXL5/OnDkjb29veXp6ys7OLs0YY4zs7OyUnJyc5UUCAAAAAAAAOU2Ggrc1a9bIy8tLkrR27VqbFgQAAAAAAAA8DDIUvNWrV8/y58DAQPn7+6e5680Yo5MnT2ZtdQAAAAAAAEAOZZ/ZDQIDA3X+/Pk07RcuXFBgYGCWFAUAAAAAAADkdJkO3lLXcvu7K1euyNnZOUuKAgAAAAAAAHK6DE01laSBAwdKkuzs7PT222/L1dXV0pecnKytW7eqUqVKWV4gAAAAAAAAkBNlOHjbuXOnpDt3vO3Zs0eOjo6WPkdHR1WsWFFvvPFG1lcIAAAAAAAA5EAZDt5Sn2barVs3TZ48We7u7jYrCgAAAAAAAMjpMhy8pZoxY4Yt6gAAAAAAAAAeKpl+uAIAAAAAAACA+8vW4G39+vVq2bKlChUqJDs7Oy1atMiq3xij4cOHy8/PTy4uLmrcuLEOHz5sNebChQt6/vnn5e7uLk9PT/Xo0UNXrlyxGrN7927VqVNHzs7O8vf31/vvv2/rUwMAAAAAAMAjLluDt6tXr6pixYr65JNP0u1///339dFHH2n69OnaunWr8uTJo5CQEN24ccMy5vnnn9e+ffsUFRWlpUuXav369erVq5elPzExUcHBwQoICNCOHTs0fvx4jRw5Up999pnNzw8AAAAAAACPrkyv8ZaVmjVrpmbNmqXbZ4zRpEmTNGzYMLVq1UqS9M0338jHx0eLFi1Sx44ddeDAAUVGRmr79u2qVq2aJOnjjz9W8+bN9cEHH6hQoUKKiIhQUlKSvvrqKzk6Oqps2bKKiYnRhx9+aBXQAQAAAAAAAFnpP7vGW1xcnOLj49W4cWNLm4eHh2rUqKEtW7ZIkrZs2SJPT09L6CZJjRs3lr29vbZu3WoZU7duXTk6OlrGhISEKDY2VhcvXkz32Ddv3lRiYqLVCwAAAAAAAMiM/2zwFh8fL0ny8fGxavfx8bH0xcfHy9vb26o/V65c8vLyshqT3j7+eoy/Cw8Pl4eHh+Xl7+//z08IAAAAAAAAj5T/bPCWnYYOHaqEhATL6+TJk9ldEgAAAAAAAHKY/2zw5uvrK0k6e/asVfvZs2ctfb6+vjp37pxV/+3bt3XhwgWrMent46/H+DsnJye5u7tbvQAAAAAAAIDM+M8Gb4GBgfL19dXq1astbYmJidq6dauCgoIkSUFBQbp06ZJ27NhhGbNmzRqlpKSoRo0aljHr16/XrVu3LGOioqJUsmRJ5cuX7186GwAAAAAAADxqsjV4u3LlimJiYhQTEyPpzgMVYmJidOLECdnZ2al///4aM2aMlixZoj179qhz584qVKiQWrduLUkqXbq0mjZtqp49e2rbtm3atGmT+vbtq44dO6pQoUKSpOeee06Ojo7q0aOH9u3bp9mzZ2vy5MkaOHBgNp01AAAAAAAAHgW5svPgv/zyixo0aGB5nxqGdenSRTNnztTgwYN19epV9erVS5cuXVLt2rUVGRkpZ2dnyzYRERHq27evGjVqJHt7e7Vt21YfffSRpd/Dw0MrV65UWFiYqlatqgIFCmj48OHq1avXv3eiAAAAAAAAeORka/BWv359GWPu2m9nZ6fRo0dr9OjRdx3j5eWlWbNm3fM4FSpU0IYNGx64TgAAAAAAACCz/rNrvAEAAAAAAAA5GcEbAAAAAAAAYAMEbwAAAAAAAIANELwBAAAAAAAANkDwBgAAAAAAANgAwRsAAAAAAABgAwRvAAAAAAAAgA0QvAEAAAAAAAA2QPAGAAAAAAAA2ADBGwAAAAAAAGADBG8AAAAAAACADRC8AQAAAAAAADZA8AYAAAAAAADYAMEbAAAAAAAAYAMEbwAAAAAAAIANELwBAAAAAAAANkDwBgAAAAAAANgAwRsAAAAAAABgAwRvAAAAAAAAgA0QvAEAAAAAAAA2QPAGAAAAAAAA2ADBGwAAAAAAAGADBG8AAAAAAACADRC8AQAAAAAAADZA8AYAAAAAAADYAMEbAAAAAAAAYAMEbwAAAAAAAIANELwBAAAAAAAANkDwBgAAAAAAANgAwRsAAAAAAABgAwRvAAAAAAAAgA0QvAEAAAAAAAA2QPAGAAAAAAAA2ADBGwAAAAAAAGADBG8AAAAAAACADRC8AQAAAAAAADZA8AYAAAAAAADYAMEbAAAAAPy/9u48LKqy8f/4ZwYEBUVwl9y31MIkzS1xIc1EzV3TJFMzxd3UKJc0K00tyi2XnlweN3DDIndFChUNySUXlDRTSxRDATFAmPP7w9+cJ9T6PksjLu/XdXnFnDnLfbrOnLnnc+4FAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAe4r4O3SZMmyWKx5PpXvXp18/2MjAwNHjxYRYsWVcGCBdW5c2ddunQp1z7OnTunNm3ayM3NTSVKlNCYMWOUnZ19r08FAAAAAAAAjxjnvC7A/+WJJ57Qjh07zNfOzv8q8siRI7Vx40atWbNGhQsX1pAhQ9SpUyft2bNHkpSTk6M2bdqoVKlS2rt3ry5evKhXXnlF+fLl05QpU+75uQAAAAAAAODRcd8Hb87OzipVqtQdy1NSUvTFF19o5cqV8vf3lyQtXrxYNWrU0L59+9SgQQNt27ZNx48f144dO1SyZEnVrl1b7733noKDgzVp0iS5uLjc69MBAAAAAADAI+K+7moqSQkJCfL29lalSpX08ssv69y5c5KkuLg43bx5Uy1atDDXrV69usqVK6eYmBhJUkxMjHx8fFSyZElznVatWik1NVXHjh27tycCAAAAAACAR8p93eKtfv36WrJkiR5//HFdvHhR7777rvz8/HT06FElJibKxcVFnp6eubYpWbKkEhMTJUmJiYm5Qjf7+/b3/kxmZqYyMzPN16mpqX/TGQEAAAAAAOBRcV8Hb61btzb/rlWrlurXr6/y5ctr9erVKlCggMOOO3XqVL377rsO2z8AAAAAAAAefvd9V9M/8vT0VLVq1fTjjz+qVKlSysrK0rVr13Ktc+nSJXNMuFKlSt0xy6n99d3GjbN7++23lZKSYv47f/7833siAAAAAAAAeOg9UMHb9evXdfr0aZUuXVp16tRRvnz5tHPnTvP9kydP6ty5c2rYsKEkqWHDhvrhhx90+fJlc53t27fLw8NDNWvW/NPjuLq6ysPDI9c/AAAAAAAA4D9xX3c1HT16tNq1a6fy5cvr119/1cSJE+Xk5KQePXqocOHC6tevn9544w0VKVJEHh4eGjp0qBo2bKgGDRpIkp5//nnVrFlTgYGBmj59uhITEzV+/HgNHjxYrq6ueXx2AAAAAAAAeJjd18HbhQsX1KNHD/32228qXry4GjdurH379ql48eKSpE8++URWq1WdO3dWZmamWrVqpc8++8zc3snJSV9//bWCgoLUsGFDubu7q3fv3po8eXJenRIAAAAAAAAeEfd18BYaGvqX7+fPn19z587V3Llz/3Sd8uXLa9OmTX930QAAAAAAAIC/9ECN8QYAAAAAAAA8KAjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAABzgkQre5s6dqwoVKih//vyqX7++vvvuu7wuEgAAAAAAAB5Sj0zwFhYWpjfeeEMTJ07U999/r6eeekqtWrXS5cuX87poAAAAAAAAeAg9MsFbSEiI+vfvrz59+qhmzZqaP3++3NzctGjRorwuGgAAAAAAAB5CznldgHshKytLcXFxevvtt81lVqtVLVq0UExMzB3rZ2ZmKjMz03ydkpIiSUpNTXV8Ye8hW+aNvC4CHgL33eci08jrEuBhcL9d15Jyfs/J6yLgAXff3a8lXc/husb/7n67tn/PSs/rIuAhcL9d1xk3b+Z1EfAQuN+u6/+V/XwM469/gz4SwduVK1eUk5OjkiVL5lpesmRJxcfH37H+1KlT9e67796xvGzZsg4rI/CgKvxpXpcAcIAPC+d1CYC/XeEgrms8pApzbePhM2ZxXpcA+PuND38479dpaWkq/BffRY9E8Pafevvtt/XGG2+Yr202m5KTk1W0aFFZLJY8LBnupdTUVJUtW1bnz5+Xh4dHXhcH+FtwXeNhxbWNhxHXNR5GXNd4GHFdP5oMw1BaWpq8vb3/cr1HIngrVqyYnJycdOnSpVzLL126pFKlSt2xvqurq1xdXXMt8/T0dGQRcR/z8PDg5omHDtc1HlZc23gYcV3jYcR1jYcR1/Wj569autk9EpMruLi4qE6dOtq5c6e5zGazaefOnWrYsGEelgwAAAAAAAAPq0eixZskvfHGG+rdu7fq1q2revXq6dNPP1V6err69OmT10UDAAAAAADAQ+iRCd66d++upKQkvfPOO0pMTFTt2rW1ZcuWOyZcAOxcXV01ceLEO7odAw8yrms8rLi28TDiusbDiOsaDyOua/wVi/F/zXsKAAAAAAAA4D/2SIzxBgAAAAAAANxrBG8AAAAAAACAAxC8AQAAAAAAAA5A8AYAAB4ISUlJkiSbzZbHJQH+PqmpqXldBAAA4EAEbwAA4L6WkZGhESNGqGnTppIkq5XqCx58ly9fVseOHfXRRx/ldVEAAIADUXMFgIdMTk5OXhcB+Fu5urqqQYMGSkxM1N69eyVJTMqOB12JEiUkSYcPH1Z8fHwelwYAADgKwRseSTk5Ofxow0PH3v3OyclJkpScnJyXxQH+ZzabTTdv3pTFYlGLFi3UoEEDTZ48WRLBGx5cNptNmZmZkqRBgwbp/Pnz2rZtWx6XCvh7ZGdn53URgL9dTk4Ow1zgf0LwhkeSk5OTLBaLjh8/rjNnzuR1cYD/2Pr16xUVFZVrmb37XVhYmPz8/BQcHKzz58/nQemAv4fValW+fPmUnJys7du3KyAgQNHR0UpISJDVaiV8wwPJarXK1dVVycnJKlq0qEqXLq29e/fq559/zuuiAf81+/3Y2dlZknT69GkzYP7j+8CDyMnJSVarVWfPnlVSUhLXM/5jBG94JNz+9O3kyZN69tln1aBBAwUEBGjOnDl5VDLgP3fixAmtWbPmji6l165dU2BgoEaNGqWWLVuqQ4cOysrKyqNSAv+77OxsvfPOOypRooRCQ0P15Zdf6vfff9fHH38siUkW8GC4/QdaWlqaBg4cqJIlSyokJERHjx5VVFSUvv322zwqIfC/s1gskqS5c+eqXLly6tixo1544QVFRETkeh94ENz+2/Hs2bNq2bKlnnjiCbVv315Tp06VRKCMfx/BGx5q9h9l9qdvhw8fliQdOHBAfn5++v7779W5c2eNHz9eX3/9dZ6VE/gzt3+hG4ahGjVqaNWqVXruuedyvRcTE6M9e/Zow4YNeuedd9SmTRtVrlz5XhYX+K/82biE8fHxWrNmjf75z3/qyy+/1Pz58xUYGKiVK1fql19+kZOTE5Ve3Lfs1+btgUN0dLQ2bdqk6OhozZ07VytXrpTFYtHGjRt16dKlvCgq8B/5s4cey5Yt0yeffKLx48dr7ty58vDw0LBhwxQeHv6X2wH3i9tbbv7444+SpO+//14+Pj6Kjo5WkyZNNH78eB04cIBAGf82i0GNFY+A8PBwvfrqq/Ly8lKhQoVUsWJFffTRR6pWrZok6dlnn1WlSpU0bdo0eXt753FpgTvFx8erevXq5mvDMLRo0SIlJCToww8/lCQNHDhQCQkJ2rhxo/Lnzy/pViXXYrFQMcB9KScnxxyTUJJu3LghNzc38/W2bdvUuXNnJSQkqFSpUpKkuLg49e3bV02bNtWsWbNks9mY5RT3lduv66NHj2rfvn167bXXZLPZNHLkSP3www+KiIiQm5ubLBaLZs2apUWLFuntt99W9+7d87D0wJ+zB2d/vOcahiGLxSLDMFS3bl0988wzmj9/viTp6tWrGjVqlGJiYnTixIk8KTPw3/j6668VFBQkq9WqqlWrKjs7WzNnztRTTz0lSWrVqpWcnJwUERGR634P/Blqqnho3J4h22w2hYaGauTIkdq2bZv5VPnmzZs6fPhwrkrDkCFDtHv3bsXGxt7rYgP/p7Fjx6pp06aSpJ9++knTpk2TxWJRbGysIiMj9f3330u69RlISUlR/vz5zSbyVquV0A33LXtlddmyZWrZsqVeeeUVLV68WGlpaZJuXe81a9bMNVZhjRo15Ofnp5UrVyo9PZ3QDfcd+3W9evVqzZ8/X2PGjNHcuXP1008/yWq16tq1a7JYLHJ3dzdbe/bu3VupqanasmWLUlNT87L4wJ+yWq2yWq1KSEjQtGnTtHPnTl2+fFnSrQmd3N3dVbZsWXP9woUL67XXXtP58+fNrtS0+cD9xB4m2/+7ZMkSLVy4UGFhYRo/frw+/vhjXb16VWfPnpW7u7u53VtvvaWtW7cqLi4uT8qNBw+1VTzw7LPM3B4uWK1WbdmyRUuXLtX169fVq1cvNWrUSB999JEKFy6snTt3muv26NFDXl5e2rZtm65cuXKvTwG4wx+73o0dO1apqany9fVV5cqVdezYMUnSSy+9JDc3N61du1aS1KlTJx0+fFgHDhwwm8hLt5rJ79mzRxIVXuSt27sZnThxQq1atdKECRPUrFkzFStWTHPmzNHbb78tSXrmmWeUkpKi7777ztzGzc1Nzs7OSk5O1qxZs+66X+Besdlsd3SVjo+P19NPP61Ro0bp1KlTunjxon788Ud9+eWXkqSuXbtq9+7d+vnnn+Xs7CybzabChQurfPny2r9/vyIjI/PiVIC/ZH+4179/f/n4+GjDhg3q27ev/P39lZCQIE9PTzk5OenixYv67bffJN2qi3t7e6t69epKSEiQxFhvuL9YrVZlZGSYE4GsW7dOAwcOlM1m04ABA9SlSxctXrxY586d04kTJ8x6dPPmzfXMM89o9uzZeVl8PEAI3vBAuXDhwh3L7LPMnDp1Sjt37jS/7CXp1VdfVYkSJXKFEAEBASpfvrx27dqVa3+vv/66Vq9erX379jn2JIC/YP8B98dm65999pkyMzN1+fJlnThxQv/85z8lSU2bNtUTTzyhmJgYnT59Wq1atVKzZs00aNAgbdu2TTdu3DC7om7fvl05OTlUeJEn/tg9KTMzU1OmTFF8fLyuXr2qJ598Uj/88IPGjRun2bNnq0aNGlq4cKF+/fVXPf3003rmmWe0Zs0abd68WdKtrktXr15VkyZNtHjxYnO/wL1m7+bs5OSkjIwMnT17VtKtLtLp6ek6fPiwQkJCFBUVpSeeeMIcw61169Z6/PHH9eabb+ry5cuyWq06duyYMjIylJaWppiYmDsG9gbupduvP3t30tjYWO3atUvR0dHas2eP9u7dKycnJ40bN06ZmZnq3LmzYmJiFB0dbW6blJSk+Ph41axZ816fBpDL3R7SRUdH67nnntPy5cslSVOnTpWXl5eKFy9urlOrVi09++yzWrBgga5evWouf/vtt7VixQpzDHHgr1BTxQNj06ZNKleunE6fPp1reVxcnJo3b6769etr1KhRatq0qdasWSPp1thtTZs21U8//aQzZ85IuvUDrUuXLjp9+rSioqLM/fTv318BAQG5xtECHGn+/PmKj4/PtcweuK1Zs0YDBgzQ/v37NWzYMEVGRioxMdHscmcP0Vq3bq3MzEyFhYVJkhYtWqTixYurR48eatmypWrVqqVLly6pd+/ejEGBe+qPFVyr1arr169r79696tKliyIiIpSenq7atWtr+PDhcnV11XvvvacyZcrohx9+UKFChTRx4kRJUnBwsCpXrqx27dqpZ8+eqlu3rlJSUrRo0SKdPHkyr04PkNVqVWJiovr3768qVapoxowZysjIUFxcnJ566ikVLlxYkuTp6amgoCBdvXpV4eHhcnJy0meffaaYmBg999xzGjlypDp06KCuXbtq9erVmjZtWq4HhsC9cvvA8snJyZL+1UptxYoVqlixomrVqiWbzabHHntMkydPVnx8vDZv3qy+ffvK29tbo0eP1qxZs7R9+3ZNmDBB/v7+1K+RZ+wPte0P6W7cuGG+V7FiReXPn1/fffedbty4oSeffFJ+fn46efKkObGCJL3//vvasmVLrpCtXbt26tSp0z06CzzoCN7wQDAMQ82aNVOZMmW0bNkyc3l8fLyGDRum2rVr6/Dhw9q7d69eeOEFffzxxzp8+LDy5cunFi1aKCsrS+vXrze36969uwoWLKh169YpKSlJ0q3AY+nSpapSpco9Pz88egzD0OrVq3Xx4sVcy3fs2KEaNWpo5MiR8vDw0JUrV2Sz2dSsWTO98MILmj59urKzs80QrUWLFqpevbqio6N14cIFlS1bVqtWrdLGjRvVr18/HTt2TBEREapYsWJenCYeQfYfbn9shXbmzBn5+/tr9OjRKleunL755hvVqVNHbm5uKleunCZPnqyvvvpK8+bNU2xsrIYNG6ZVq1aZLeLmzZunRYsWydPTU2PGjNGGDRtUqVIlWSyWP50RFXC0uLg4+fn56cKFC1qyZIm6dOmi/PnzKzMzUykpKcrKyjID6I4dO+rGjRvauHGjUlJS1LhxY61bt06dOnXSyZMnNWrUKL3xxhtq2LChJIYFQN6wB2yzZ89WtWrV1LFjR82aNct86Jc/f35du3ZNrq6u5jXaoUMHWa1W7d+/X25ublqwYIHatGmj0NBQ9erVS8WKFdPnn38uLy+vPDsvPHoSExO1evVqSf96qJ2Tk6Nhw4Zp/Pjx5r25TJkyatmypY4fP65t27ZJujX2t31SHLumTZuqevXqCgkJUUpKiqRb9Zy1a9eaEy4Af8kA7nM3b940/54+fbpRvHhx4+LFi+ayTz75xPx748aNRtWqVQ03NzcjKCjIMAzDSElJMQIDA402bdoYly9fNtedOXOm8f777xvp6emOPwngD3Jycv70vS5duhgDBw6863vffPONYbVajZiYmFz7CQsLM2rVqmVMnTr1T4+XnZ39P5Ya+Gu3X2Pnzp0zQkJCzOWvv/664ezsbMyfP98wjH/d28+cOWMULlzYWLNmjbntq6++algsFiM4OPhPj/dXnyPgXhg1apTRunVr87XNZjMMwzB27dplODk5Gfv27cu1fp06dYwyZcoYy5cv/9N92vcB3Gs3b940tm/fbsyYMcNo3ry58dlnnxnDhg0zqlevbgQEBBiGYRhfffWVkS9fPiMhIcEwDMPIysoyDMMwWrdubXTt2jXX/i5fvpyrjs21jXtp/vz5hsViMZKTk40VK1YY7dq1MzIzM40BAwYY/v7+ue7Pp06dMpo3b24EBQWZdYumTZsaPXr0MM6fP2+uFxYWZvTo0eOO347UsfHvoMUb7nv2gYeXLl2qRo0aKTU1VRs2bDDfHzFihH788Uf5+flp6NChevnll9W/f3/t2LFDCQkJ8vDwUIsWLXThwoVcreWGDRumcePGyc3NLQ/OCo8qwzDMlkCGYejTTz/VhAkTJEnHjx9XQkKCOQ7Kd999p5MnT+rEiRO6ceOGmjRponr16umjjz5SVlaWrFarjh49qvbt26tBgwZ37cZhPx7dTOFo9mts8+bNmjNnjsaOHauZM2eaT5B79eql8uXL66effpL0r65Mbm5ucnFxUWJioiSZs/QOGTLkjqEFpDu7jAB5xcXFRUeOHNHu3bs1Y8YMffjhhxo0aJDc3d1Vq1YtTZs2Tbt27ZIkbdmyRd7e3vL19VVUVJQ5hpbx/1sN2a9rxuGEo9lstruOdfXVV18pMDBQn332mfr376+goCDNnDlTISEh+uabb/Tll18qICBAdevW1aBBg5ScnKx8+fIpISFB58+f14svvphrf8WLF5ebm9ufToIG/J2M21oJ9+vXTx4eHqpSpYqGDRumJk2ayMXFRa+99ppSUlK0detWc92qVauqbt26+u6778zZd4cOHapdu3bpm2++Mdfr1q2bVq5cecdvR+rY+HdQa8V95fabpiSFh4eraNGimjt3rpYuXaqsrCwtWLDAHHdCkmbMmKFSpUpp586dmjhxop566imdO3fOHCizZcuWqlu3Lt3tkGfs17bFYtGFCxcUFBRkDhb/8ccf68qVK3r88cfl4+OjTz/9VOXLl9ekSZP0wgsvqGXLlho7dqwk6YMPPtD69evVrVs3lS5dWv369dPNmze1YMECdejQ4Y7jUtHFvfLbb7+pU6dOeumll3T27FldunRJv/76q/mgxM/PT3Xr1tWJEydyjc3m4eGhgQMHasyYMapdu7b8/Pzk7e2tGTNmmON1/hEVXNwvhg8frqpVq6pr166KjY3V999/r/3792v48OHq1q2bMjIy1K1bNzVo0EBdunTRgAEDVKZMGf3888/mDHr2ezTXNe4Vq9Uqq9Wqn3/+OVdXuo4dO6pRo0a6dOmS6tSpYy5v0qSJOnfurClTpsjJyUlz587V8ePH1ahRI/Xu3VtNmjRRiRIl1KJFi7sezz4JGuAIhmHcdfKwf/zjH0pNTZVhGDp69KhGjx4tSapbt66eeuopxcTE6NChQ+b67dq108mTJ81ArnPnzqpSpYry589/xzEZ4gL/lTxrawf8QXZ29h3dhnJycozff//d6Nixo/Hqq68aNpvNuHr1qhEaGmq4uLgYixYtMgzDMK5cuWI888wzxsiRI81tg4ODjXLlyhklS5bM1S0VuJfs17T9v2fOnDG+/fZbs0vGoUOHjGvXrhklSpQwpkyZYhiGYSQnJxuhoaHG5s2bjW3bthkHDhwwZs+ebbi5uRmXLl0yDMMw1q9fb4wePfqO7kp0vYOj3a3bsv26i46ONkqWLGkcOHDAfO/ll182fH19jR07dhiGceva9fX1NebOnXvHvr/++mvjk08+MX7++edcy+nCgftZSkqKkZOTYyQnJ5td6VxcXIzw8HAjLS3NWLVqlfHRRx8ZZ86cMQzDMHr37m3UqVOHbne4Z/44ZIvNZjPS0tKMHj16GIUKFTK8vb2NQYMGGSdPnjQMwzD++c9/GpUqVTLmzZuXax+LFy82atSoYd6fjxw5YsyfP9/o27evsXr16nt3MsD/l5OTk+s+evXqVWPRokVGZGSkuSwlJcXw8vIyhyWy11d27dpl1KlTx/jggw/MdadNm2Z4e3sbtWvXNod04T6Nv5PFMBi9FfePkydPKiEhQfXr11fx4sWVkZEhT09PrV27Vm3btjXX69u3r+Li4hQbG6uMjAwNHz5c+/fv1wcffKC4uDgdOnRIgYGBKleunBo2bGhOgw7klezsbJUrV07u7u56/vnnNWvWLLOFw4QJE7R06VIdOnRIRYoUuWPbd955Rz/88IOWLFlizpL3Rzk5ObSWwN/OZrPl6hZt/KGb9M2bN3Xt2jUVL17cXH/GjBkKCwvTxo0bVbJkSUnSvn37FBwcrFq1amn27NmSbrWqyJ8/vz788EOVL1/+rtev/ek1rSTwoMjMzJSrq6vmzZunZcuWaeHChXryyScl3br/Ozs7a/ny5Zo8ebKmTJmiLl265HGJ8bC7/d566NAhVapUST/88IOWLVumiRMnasOGDVq6dKl8fX01b948paen68UXX1TRokW1cOFCeXp6SpLGjBmjyMhIRUVFqVChQv/W8YB7ISMjQytXrtSoUaNUqlQp/fLLLxo+fLjeeOMNeXl5adSoUfryyy8VGxuba4KPUaNGad26dQoMDJSnp6f27NmjgIAAVahQIVfrTa5r/F2o0eK+cODAAfn7++vZZ5/VmDFjVL9+fYWFhSk9PV0+Pj5mU2D7mCh9+vTRDz/8oM2bN5vdlGrXrq1Ro0Zp48aNGjNmjLp3727ODkbohnvh9ucYhw4d0siRI3X06FE5Oztr1KhROn36tLy9veXk5GSOsTJ48GAlJydr3bp1kqSrV68qIiJCmzZtUvfu3fX555+rTZs2d4Ru9u2pEODvNn36dAUGBpqv7SFYUlKSBgwYoBo1aqhjx4764IMPdO7cOUm3xmq7ePGisrOzzc9CgwYN5OXlpV27dungwYOSpICAAO3Zs0ffffedpDuvX8Mw6JqEB0ZWVpbCwsI0YMAAPf7445o8ebKCgoLM0O3q1av68MMPVbVqVY0cOVL9+vVTp06d8rjUeBTY760HDx5U1apV1bhxYwUEBCg4OFgNGjRQ6dKlFRQUpM6dOysqKkpxcXFyd3dXhw4dFBkZqaFDhyomJkYxMTGKjIyUv7//XUM3e7c76iJwpLt175wwYYL69++vb775RmvXrtUPP/ygKVOmaMmSJfr6668lSSNHjtQvv/yijRs35tp21KhRev3117VlyxYtXbpUPXv21GuvvXZHl2mua/xdqNUizyUkJOjDDz9UtWrVdPz4cR06dEgDBgzQW2+9pVOnTunpp59WTEyMUlJSzMG4r1+/LulW//2MjAzVr19fy5YtU3R0tA4ePKimTZvm5SnhEXV7wHvy5Elt2bLFHFy+X79+Kl++vC5fvqzr16/LarXKZrOpVKlSevXVVzVr1ixlZWVJkjZs2KDg4GDly5dPu3fv1muvvXbH8Qgm4CiPPfaYQkNDdeLECXPZ9u3b1aJFC/3yyy+aOXOmunbtqsjISH3wwQeSpN69eys5OVkbN27M9VkoUqSIzp07p7Vr15rrLV26VF27dr3rsXlQggeJi4uLKlWqpIIFC2rSpEm6ePFirtDay8tLfn5+mjhxopKSkhQcHMy9G3+7u3Vg2rZtm7p166bdu3dr4MCBOnDggCpWrKi9e/eawbAkNW/eXKVLl9bChQslST179lS1atW0fft2ffTRR3rllVdUo0YNc6zZ2xFMwJFuD3b/eK1XrFhRK1as0M8//6zmzZvL2dlZQ4YMUc2aNbVx40adPXtWZcqUUa9evfT+++/r7NmzSkpK0sKFC+Xt7a2xY8dq06ZNOnLkiNkKmc6AcJg86uIKmM6ePWuEhYWZr8PCwoynn37asFgsxowZM4zFixcbTz/9tDFu3Dizr/2MGTOM7t27GxaLxThx4oRhGPTDx711+/Vms9mMFStWGOvXrzeX3bx50+jRo4fRoUMH4+zZs4ZhGMbw4cONevXqGbGxsbn2c/r0acNisZhjF545c8ZIS0sz93X7WBaAI/xxLKCaNWsagwYNMl/v37/fePPNN83XCQkJhq+vr1G6dGlj165dhmEYxtChQ41KlSoZoaGhhs1mM44ePWp06dLF6NKli9G2bVvzcwA8TG6/N//xcwQ40t3G3bT7+uuvDYvFYlSvXt04d+6cYRi36hoNGzY0unXrZq6XlZVlvPvuu4aPj4+RkJBgGIZhvPvuu0bLli2NZcuW5don9RDkldDQUKN79+7GW2+9ZWzdutVcXqdOHaNdu3ZGcnJyrnVr1KhhjoV85coVo1SpUsZTTz1lWK1Wo0OHDsbVq1dzjY3MfRuOxiM35Lny5curW7duOnXqlJ577jm9/fbb6tu3r8aMGaM5c+aoRo0aGj58uKZMmSI/Pz899dRTmjVrliZPnqzU1FRVr15dEq0kcG/YbDbZbLY7rrf09HRNnTpV69ev17Vr1yRJzs7OCggI0K+//qpNmzZJkkaMGKFff/1V33zzjW7evCmLxSLDMFSpUiUNHDjQnD2pYsWKKliwoHk8q9XKNQ6Hs7cqvnDhgkaMGKGVK1fqzJkzkqR69epp0qRJOnPmjF588UXVr19fjz32mCpUqKD58+dLujXOW8OGDTV48GDVq1dPtWvXVuPGjdWqVSudOHGCJ8l4KNnvzfbu//bPEeBoVqtVTk5OSkpK0tq1a3XhwgVzxtz69eurffv28vLyUtmyZSVJZcuWVe/evbVlyxZzmIB8+fLJ399f0q17uCQFBgYqNTVVhw4dMu/b2dnZ1ENwz127dk1t2rTRiBEjVKlSJcXHx2vQoEH6/PPPJd1qRX/y5El9//335jbdu3dXiRIlFBUVpfPnz6to0aLauXOnxo4dq1OnTik8PFyenp65Wh9z34ajEbwhz9m/0L/44gvly5dPO3fu1ODBg9W+fXtduHBBe/fu1SuvvKJ9+/apbdu26t69uxISElStWjUVLFgwj0uPR43VapXVatXZs2c1f/58HTlyRNeuXVPBggX16quv6scff9Q333xjrt+uXTuVLFlSUVFRunLliipUqKDnn39eGzdu1PHjx3Pt+7PPPlOPHj3uejzgXti4caOqVaumdu3aacuWLUpJSTG7iEq3Aobx48fL3d1d0dHRioiI0OOPP649e/bo8OHD5uDy4eHh6tWrl7777jsNHz5cFotFly9fNoNl4GHEvRr32oULF/Tyyy+ratWqeuedd/T888/rzTfflHSrm39gYKD27dunhIQESbdCtqZNm6pq1apmyCZJvr6+6tOnjzp06CDp1sO/Zs2aKTIyUtu3b5dEMAHHsdlsdx3DTZIiIiJ048YNHT16VFOmTFF4eLhKly6tcePGKS0tTQMGDJAkbd26VWlpaeZ2Xbp0UUREhDm+bM2aNdWtWzdVrlzZfKgN3FN52+AOuCUnJ8coXbq0MXXqVHPZ22+/bbi7uxtFixY1py8H8trly5eNnj17GgULFjQaNGhgVK1a1WjZsqWRlZVlJCUlGQ0bNjSGDBliXL9+3dzmvffeM7y9vY3Vq1cbhmEYsbGxRv78+Y1169bdsf8/NnsHHOHPuiZdvXrVaNiwoREUFGQkJycbX331ldG2bVvD29vbuHjxomEYhnHkyBGjUKFCxldffWXuq3379oazs3OurkuGcav7kmEYxq5duwwfHx9j8uTJDj4zAHh4/PTTT4Zh3OreebducJcvXzYGDx5sdOnSxThy5IiRlZVl7Nixw7BYLMY333xjGIZhJCcnG08//bTRu3dvc7vMzEzjo48+MiwWS67ueXb27qSHDx82evbsaRw9evTvPzngLlJSUoyff/45V134zTffNIYMGWIYhmGMGzfOKFGihFGrVi1j0aJFRkZGhmEYhjFp0iTj6aefNvbs2WNul5GRYSxfvvyOejXdpZFXeDSH+4LValWzZs00b948LVy4UBMmTNChQ4f0/fff6x//+IfKlSuX10XEI+DKlSuSbrXCtM+ga2f8/5aZEREROn/+vL7//nvFxMTohx9+UFRUlMaMGaNixYopICBABw8e1J49e8xts7OzlZ6erhUrVig1NVV169bV999/f9eZ7WgxAUeyd1t2cnJSZmamLl++bL63b98+xcXF6c0335SXl5fatWunWbNm6caNG1qxYoUkmTNNR0VFKSMjQ4sXL1aBAgX0wQcf6LnnnjM/J7///rvCwsLk4+OjDh06qHnz5hoxYkRenDIAPHCmT5+uTp066fjx47JYLGZrs9TUVHMdT09P1alTR59//rl8fHy0b98+hYSEmNtnZ2fLy8tLQ4YMUWhoqHm/d3Fxkb+/vwYMGKD09PRcx/3jUBq1atXSihUr9MQTT9yLU8YjJCcnx6wvGIahGzduaNCgQSpdurQ6dOigwYMHS7p1PV65ckVRUVEqXLiwdu7cqTlz5iguLk59+vQx9zd06FCdOXNGGzZsMLtau7q66uWXX76jXk13aeQVfuHhvjF79mw9++yzCgkJ0bZt2zRixAhVq1bNbPYOOFL79u01ZswYJSUl5ark2mcZtX9Rh4SEaMSIEapatarWrVunF198UU5OTqpUqZIk6eWXX1aBAgU0Y8YMnThxQnFxcfrll1/UtWtX1a9fX9KtikSNGjXy4CzxqLNarbp8+bIGDBig6tWrq1OnTuaMuYUKFVKhQoVyjedTsWJFvfzyy5o3b56uX7+u2rVrKyAgQKtWrVLlypX11ltvqVu3bnrzzTf1+uuvm5+TAgUKqGHDhnrjjTeUmJiomTNnqlChQnl23gDwILDff6tVqyZ3d3d9/fXXkqSlS5eqXr166tKli9asWaO0tDTly5dPPXv2lLOzs3r16qWePXuqSpUqWrlypTZt2qTo6GhJUkBAgEqXLp1rVlJfX1/NmzdPZcqUyXV8Hv7BkezdO52cnGSxWHThwgVlZ2frzJkzSk9P144dOxQYGKjFixdr/vz5slqtatCggX799VeNHTtWMTEx6tq1q5ydnXXp0iWNHj1ap0+fVpEiRTR+/Hi1bdtWrq6ueXyWwN1xd8V9o2jRovrnP/+p6Oho7d+/X88//3xeFwmPAPuYEvXr11dsbKzi4+MlSTNnztSzzz6roUOH6tChQ+a6JUuWVFhYmOrWrashQ4aobt26On36tIYNGybp1rgow4cP19WrV9WmTRs1aNBAFStW1MyZM/X222/Lw8ODii3yzL59+xQQEKDz589r/vz5GjFihHbs2KFx48bp999/V61atbR8+XJJtyrGkvT444/rzJkz+uqrr5Q/f36NGzdOERERWrx4sZKSktSxY0dJt34wGn+YPKFy5crq06cP47oBwL/BZrOZre1bt26tatWqKTo6WkuWLNHy5cvVrVs3FS5cWBMmTNCSJUsk3WrVs2bNGiUkJCgsLEwzZ85UgwYNVLhwYa1YscKst4wYMULFihW745h/Nq4W4Aj2+u/Ro0f17LPPqlatWnrxxRfVr18/vfjii2rYsKFGjhyp0aNH64MPPtCNGzfUrVs3lStXTjExMTp48KDS0tKUkJCgcePG6eTJk2Yr0FGjRqlJkyZ5eXrAX7IYBlOMAXh0GYYhi8Vihg59+vSRYRjatGmT/P39tXHjRmVkZGj58uXy8fHR4MGDFRYWpuDgYI0YMUJubm6SpNOnTysuLk7dunWTJCUnJ2v//v1q0KCBvLy8zGMZhkHwhjyzc+dOnT59Wq+//rok6ddff1Xbtm2VkpKizz77TBs3btTu3bu1adMmlSpVSpIUFBSkpUuXytvbW0eOHDGvebvs7GwG3QaA/4F9GADpVpd+m82mXbt2aerUqUpNTdX48ePVo0cP3bhxQ2PGjNHhw4e1atUqlS1bVu3atVNWVpa2bt0qSVq1apXGjRuns2fPKi4uTr6+vnl5aoApKipKJ0+e1JEjR1S0aFHVq1dPixcv1pdffqlt27aZs+smJiaqSpUq+uijjzRw4EDt2LFD06ZN0+HDh1WtWjUdPHhQ/v7+mj59eq4eJH/8HAH3G65MAI80i8WinJwcFShQQF27dtU//vEP7dixQwsWLNB7772n3bt3y2Kx6J///KcsFoueffZZPfbYYypZsqQZQKSnp2vx4sVau3at+eStSJEiat26tby8vMyxLCwWCxUC5Kk6deqod+/eOnPmjDp37qwnnnhCdevWVVpamnbs2KEOHTqoSJEieuaZZ/Tuu+8qMDBQCQkJiouLU2ho6B2hm8RMdwDwv7JarUpMTFT//v1VpUoVTZw4UX5+fqpQoYJ++eUXsxeIm5ubWrdurZycHC1btkzSrdnTt2/frk8//VQhISEKCQnR0qVLFR4enit0MwyDmRzhcHcbJ9kuJiZGQUFBio2N1ciRI9W2bVuFhYWpQIEC2rdvnzm8S6lSpfTqq69qzpw5+v3339WiRQutW7dOW7duVb9+/XT06FFFRESoRo0auVraU8fG/YyrE8Ajz/5FPXr0aN28eVNpaWmqXLmypFuV3J49eyo6Olrfffedunbtqk6dOmngwIFq27athg0bpmrVqikiIkJ9+/aVh4dHrn0bhmGOZQHkNU9PT7m6uur9999XTk6Odu/erYULF2rgwIFas2aNihYtqrVr16pHjx7aunWr0tPTNXv2bNWoUUN169bN6+IDwEMpLi5Ofn5+unDhgpYtW6Z27drJy8tLbdq0UenSpRUeHm6u26RJE9WqVUtbt27VtWvX9Prrr2vQoEEKDQ3VvHnzNHDgQPn5+al9+/a5jsHDP9wL9nGSb968qS+//FJxcXFml+ZRo0apZs2aZl1EuvXwLigoSF988YXOnz9v7ueNN97Q8ePHtXr1akmSh4eHfH191adPH1WsWFE2m005OTnUr/HA4O4L4JFnsVhks9lUpEgRdenSRdnZ2Tp27Jj5fv/+/ZWVlaWIiAhZLBa9//77Wrp0qerWraukpCSFhITo8OHDeuGFF+66b+B+Ehsbq/Xr16tPnz564oknlJGRocOHD+vcuXP6/PPP5ebmpunTpysyMlLr16+/44kyAODvtWrVKlWtWlWbN29WixYt1Lx5c0lSy5YtVaNGDW3ZskUZGRmSbgUQLVu21I0bN7Rw4UJJtyZ+ioiIUEJCgvr165dn5wFkZ2dr0qRJ8vLy0oQJE9SqVSsNHDhQx44dk4uLizp27Khff/1VBw8eNLeZMGGCzp07p+3bt5shXaVKlTRw4MC7TpZgH7bFPhYt8CAgeAPw0Pqzpu5/ZciQIbpy5Yr27Nljbl+iRAm1bdtW33zzjfbs2SNJ6tmzpyZNmqRVq1ape/fukhikGA8GHx8f3bx5U4cPH9bPP/+sNWvW6Mknn9TkyZNVuXJlubi4SJLy588vm80mm81GgAwADuTi4qIjR45o9+7dmjFjhqZOnaqgoCCdP39ejRs31uXLl/XVV1+Z6zdu3FiVKlVSenq6uX3x4sUl/Xd1H+A/9Wd13t27dys8PFxLlizR/v37FRISooSEBA0ZMkSSNHToUF2/fl27du0yw+RChQqpd+/e+vDDD3XhwgVzX5999pleeumlO45BnQQPIiZXAPDQsY+nZnf69GmVKVPGfGp2+/t29kFZe/XqpcTERLOLnSSdPHlSbdq00YwZM8xZHO1ycnJ46oYHypQpU/SPf/xDKSkpcnJy0uzZs80AGQBwb126dEkvvfSS4uPj5efnJ8Mw9NNPP8lms6l///6KjIyUk5OTQkNDzW3S0tJUqFChPCw1IGVlZZkP7KRb3Uk3bdqkEydOmMu2bNmidu3a6ZtvvlGjRo00ePBgHTx4UHPnzjXHITx37py6du2q9evX67HHHjO3ZcIEPCwI3gA8tObOnatp06bJy8tLRYoU0RtvvKF27dr96fr2L/eDBw+qY8eOCg4O1sCBA82Q7tq1a/L09LxHpQcc6/Tp0zp37pzZpUmS2bqNp8kAcG+lpqaqYMGCSklJkaenpywWi1xdXbVhwwbt27dP27dv1+LFi/X444+b2zBbOu4V+0Nm+8PryMhIvffeeypdurRat26twMBAZWdna+TIkbpw4YJCQ0PNB96//fabunXrJm9vby1btkxnzpyRn5+fgoKCFBwcrHz58uXx2QGOx10awAPtz2boWrZsmT755BONGzdOc+bMkYeHh4YNG2YOUHy3JvJWq1WGYcjX11dlypRRVFSUrl27Zr7v6enJjGB4aFSuXNkM3exdk6xWK6EbAOQBDw8PWa1Wubm5yWKxaN68eapdu7aefPJJjR49Wrt27coVuklMmADHs7fRsffssFgsunjxot555x2ztVqfPn20adMmOTs7q0SJErp8+bIOHDhg7qNIkSIqVKiQPD09lZWVpUqVKqlp06a59m9HV2k8rGjxBuCBZA/A/ljhtD+FMwxDdevW1TPPPKP58+dLkq5evapRo0YpJiYmV/P329mf6P3yyy8qXbo0FVoAAOBwWVlZCg8P1+bNmxUTE6PU1FRNnz5dgYGBZv2Gbne4V24flmXWrFlat26d/P39lZycrCeffFL9+/fX77//rqFDh2rfvn06evSozp8/rzZt2qhp06b6+OOP5eLiouTkZDVs2FDDhw/XoEGDJN0K2JydnfPq9IB7jjs3gAeS1WqV1WpVQkKCpk2bpp07d+ry5cuSpOTkZLm7u6ts2bLm+oULF9Zrr72m8+fP69tvv5V099Zy9mcRjz32mKxWKxMmAAAAh3NxcVGlSpVUsGBBTZo0SRcvXlRgYKCkfw0mT+iGe8VisSg7O1sHDx7U5MmTFRYWpurVq+urr77S7Nmz5e3tLUkqUKCA3nzzTZ06dUpr1qxR2bJl9frrr2vnzp1q0KCBPvjgAz333HPy9PRUq1atzP07OzvLMAx6kuCRwd0bwAPHMAylpKSof//+8vHx0YYNG9S3b1/5+/srISFBnp6ecnJy0sWLF/Xbb79JulVZ9fb2VvXq1ZWQkGAus+/P3rTd/vQtNjY2D84MAAA8qurWras5c+aoR48ekuh2h7z1/vvvy8/PTzt37tQXX3yhBQsWaO3atXJ2dtbp06d18+ZNSVK1atXUqVMnffzxx5KkIUOGaMWKFWratKkiIyPVoUMH7dmzR5UrV861f7pK41HClQ7gvnZ7pdPe9D02Nla7du1SdHS09uzZo71798rJyUnjxo1TZmamOnfurJiYGEVHR5vbJiUlKT4+XjVr1pR0q1tpTk6OLBaLGbjNmDFDJUqU0KuvvspspQAA4J6xt2yztwKiKx7ygr33x9ChQ1W8eHH9/vvvKl++vCSpYsWK6tmzp5YsWWL2NJGk4OBgxcXFafPmzZIkX19fhYSEaOfOnZo4caKcnZ3pRYJHGsEbgPuS/UvfXulMTk6W9K9K6YoVK1SxYkXVqlVLNptNjz32mCZPnqz4+Hht3rxZffv2lbe3t0aPHq1Zs2Zp+/btmjBhgvz9/VW9enVJtwaKdXJy0vXr1xUcHKxixYpp5cqV+vjjj3XgwAFCNwAAcM/RCgh5yT6eYNGiRdWhQwdlZWXp2LFj5vuTJ0/WoUOH9O2335r1dV9fX9WtW1fbt2/PtR/p1oNuwzCoV+ORxl0dwH3J/mU9e/ZsVatWTR07dtSsWbN0/vx5SVL+/Pl17do1ubq6ml/6HTp0kNVq1f79++Xm5qYFCxYoICBAoaGh6tWrl4oVK6aFCxfKy8tL0q2KwLhx4+Th4aHY2FgtWrRIcXFxCgwMVIECBfLmxAEAAIC/2X/TdXnIkCG6cuWK9uzZY25frlw5tW/fXvPmzdOlS5fMdbdu3aqQkJA79uHk5MSM6XjkMaspgPtOdna2oqKidOjQIW3atEldu3ZVfHy8tm3bpkqVKmnjxo2KiIhQ586ddfz4cVWpUkU3b95Uvnz5FBAQoIIFC2r16tXm/pKSkuTu7i43NzdJ/+qumpGRofDwcJUqVUrNmzfPq9MFAAAAHOL2GUpPnz6tMmXKyNXV9a7v29ln0e3Vq5cSExM1e/Zs1ahRQ5J04MAB1atXT3FxcfL19b3rdgD+heANQJ6xj2Fy+5fz+vXrNXjwYBUoUEAffPCBOcjw5s2b1bVrV61YsUJt27aVn5+fChYsqNDQUBUpUkQJCQnq1KmTgoOD1atXrzuOZx/PjcoAAAAAHiVz587VtGnT5OXlpSJFiuiNN95Qu3bt/nR9e4B28OBBdezYUcHBwRo4cKAZ0iUlJal48eL3qvjAA41fnwDyjNVqldVq1c8//6x9+/aZyzt27KhGjRrp0qVLqlOnjrm8SZMm6ty5s6ZMmSInJyfNnTtXx48fV6NGjdS7d281adJEJUqUUIsWLe56PCcnJ0I3AAAAPJTsD7Vvt2zZMn3yyScaN26c5syZIw8PDw0bNkzh4eGSdNeJD6xWqwzDkK+vr8qUKaOoqChdu3ZN0q1WcsWLF2fCBODfxC9QAPfMH8eWMAxD169fV8+ePeXj46POnTtr8ODBOnXqlCwWizp06KBSpUopMjLS3Mbd3V3NmzdXWlqazp07J19fX23evFkjR46Us7OzZs2apZ07d6pUqVJ5cXoAAADAPWez2e7o4mnv2GYYhj799FO1aNFCAwYMkJ+fn5YsWaLmzZtr7NixkvSnEx/Yg7ywsDCtWrXKHCfZ3uqNCROAfw/BGwCHsz8Ns89QeujQIaWlpenw4cPy8PDQyZMnNX78eMXFxemTTz6RJHXq1EkVKlRQZGSk+XRNko4dO6YCBQqYX/w+Pj4aMGCAvvjiC3Xt2jXX8QAAAICHnb0XSUJCgqZNm6adO3fq8uXLkqTk5GS5u7urbNmy5vqFCxfWa6+9pvPnz+vbb7+VdPfWcvbw7rHHHpPVaqWODfyXCN4AOJz9adjBgwdVtWpVNW7cWAEBAQoODlaDBg1UunRpBQUFqXPnzoqKilJcXJzc3d3VoUMHRUZGaujQoYqJiVFMTIwiIyPl7++vQoUK3XEce2WAp28AAAB4FBiGoZSUFPXv318+Pj7asGGD+vbtK39/fyUkJMjT01NOTk66ePGifvvtN0m3gjpvb29Vr15dCQkJ5jL7/uy9VOwPzWNjY/PgzICHB8EbgL/V3eZr2bZtm7p166bdu3dr4MCBOnDggCpWrKi9e/fqySefNNdr3ry5SpcurYULF0qSevbsqWrVqmn79u366KOP9Morr6hGjRpms/jbEbgBAADgYfXHYVukf81IGhsbq127dik6Olp79uzR3r175eTkpHHjxikzM1OdO3dWTEyMoqOjzW2TkpIUHx+vmjVrSrr1ANs+EZk9cJsxY4ZKlCihV199VTk5OdS1gf8SwRuAv4XNZjO/rG938+ZNrV27Vp999pm6deum6tWr691331WDBg00Y8YMc72nnnpKzZo1U0xMjH788UcVLVpUL7zwgmrVqqWOHTsqISFBy5cvl5eX110DPgAAAOBhY6/32gOx5ORkSf8aa23FihWqWLGiatWqJZvNpscee0yTJ09WfHy8Nm/erL59+8rb21ujR4/WrFmztH37dk2YMEH+/v6qXr26pFsPsJ2cnHT9+nUFBwerWLFiWrlypT7++GMdOHCA0A34HxC8AfhbWK1WOTk5KSkpSWvXrtWFCxeUmZkpSapfv77at28vLy8vc3yJsmXLqnfv3tqyZYvOnTsnScqXL5/8/f0lyQzkAgMDlZqaqkOHDpmVjuzs7LsGfAAAAMDDxl7vnT17tqpVq6aOHTtq1qxZOn/+vCQpf/78unbtmlxdXc36cocOHWS1WrV//365ublpwYIFCggIUGhoqHr16qVixYpp4cKF5rjJOTk5GjdunDw8PBQbG6tFixYpLi5OgYGBKlCgQN6cOPCQsBg0GwHwN7hw4YKCg4O1ceNGeXt7S5JatmypmTNnymazacOGDerSpYtOnjypqlWrSpLi4+PVq1cvNWzYULNnz5Ykpaena+HChapevbpat24tSXrrrbe0bds2ffjhh3r++efz5gQBAACAeyw7O1tRUVE6dOiQNm3apK5duyo+Pl7btm1TpUqVtHHjRkVERKhz5846fvy4qlSpops3bypfvnwKCAhQwYIFtXr1anN/SUlJcnd3l5ubm6R/dVfNyMhQeHi4SpUqpebNm+fV6QIPJYI3AP+ns2fPqkKFCjIMQzk5OWYzd7ukpCS9++67unTpkt555x1Vr15d3377rVq2bKmoqCg1adJEV69eVYsWLeTj46MlS5ZIkrKysjR79myNGTNGv/32m/nEzc5eEThy5IimTZumsWPH6oknnrhXpw0AAADcE/ZZRe2THNitX79egwcPVoECBfTBBx+oR48ekqTNmzera9euWrFihdq2bSs/Pz8VLFhQoaGhKlKkiBISEtSpUycFBwerV69edxzPPkTM7ccD8PfjUwbgL02fPl2dOnXS8ePHcw22mpqaaq7j6empOnXq6PPPP5ePj4/27dunkJAQc/vs7Gx5eXlpyJAhCg0NNac3d3Fxkb+/vwYMGKD09PRcx7XZbGaz+lq1amnFihWEbgAAAHgoWa1WWa1W/fzzz9q3b5+5vGPHjmrUqJEuXbqkOnXqmMubNGmizp07a8qUKXJyctLcuXN1/PhxNWrUSL1791aTJk1UokQJtWjR4q7Hc3JyInQD7hE+aQDuyt4Ytlq1anJ3d9fXX38tSVq6dKnq1aunLl26aM2aNUpLS1O+fPnUs2dPOTs7q1evXurZs6eqVKmilStXatOmTeYMSgEBASpdunSuWUl9fX01b948lSlTJtfxqQgAAADgYfXHGUoNw9D169fVs2dP+fj4qHPnzho8eLBOnToli8WiDh06qFSpUoqMjDS3cXd3V/PmzZWWlqZz587J19dXmzdv1siRI+Xs7KxZs2Zp586dKlWqVF6cHoA/4JctgDvYbDazMtC6dWtVq1ZN0dHRWrJkiZYvX65u3bqpcOHCmjBhgtlt1NXVVWvWrFFCQoLCwsI0c+ZMNWjQQIULF9aKFSuUk5OjkiVLasSIESpWrNgdx8zJybmXpwgAAADcc/Y6r70XyaFDh5SWlqbDhw/Lw8NDJ0+e1Pjx4xUXF6dPPvlEktSpUydVqFBBkZGRunbtmrmvY8eOqUCBAuZwLT4+PhowYIC++OILde3aNdfxAOQdgjcAudhsNlmtVuXLl0/p6enKyspS+/btdeXKFc2YMUN9+/bV6NGjtXTpUj333HMKCwszZ1Rav369PD091ahRI0lSTEyMvLy8tGjRIh05ckSSNHz4cH344Yd3HJcpygEAAPCws9d5Dx48qKpVq6px48YKCAhQcHCwGjRooNKlSysoKEidO3dWVFSU4uLi5O7urg4dOigyMlJDhw5VTEyMYmJiFBkZKX9/fxUqVOiO49gDN+rYQN4jeAOQi9VqVWJiovr3768qVapo4sSJ8vPzU4UKFfTLL7+Ys4q6ubmpdevWysnJ0bJlyyRJ7dq10/bt2/Xpp58qJCREISEhWrp0qcLDw+Xr62sewzAMcwBZAAAA4GF0t3kMt23bpm7dumn37t0aOHCgDhw4oIoVK2rv3r168sknzfWaN2+u0qVLa+HChZKknj17qlq1atq+fbs++ugjvfLKK6pRo0auIVz+iMANuH84/9+rAHiUxMXF6aWXXlKVKlW0bNkyOTk5ycvLS23atNGhQ4cUHh6u1157TdKtQV0jIiK0detWDRo0SK+//rqOHDmi0NBQ/fbbb3rrrbfk5+d3xzEsFos5cQIAAADwMLHZbDIM467h182bN7V27Vr98MMP2rZtm8qWLat3331Xp0+f1owZMxQWFiZJeuqpp9SsWTOtXbtWP/74o6pUqaIXXnhBu3fvVseOHbVu3Tpzn4ZhULcG7mO0eAOQy6pVq1S1alVt3rxZLVq0UPPmzSVJLVu2VI0aNbRlyxZlZGRIkjw8PNSyZUvduHHDfBoXEhKiiIgIJSQkqF+/fnl2HgAAAEBesFqtcnJyUlJSktauXasLFy4oMzNTklS/fn21b99eXl5eKlu2rCSpbNmy6t27t7Zs2aJz585JkvLlyyd/f39J0owZMyRJgYGBSk1N1aFDh8zWdNnZ2YRuwH2O4A1ALi4uLjpy5Ih2796tGTNmaOrUqQoKCtL58+fVuHFjXb58WV999ZW5fuPGjVWpUiWlp6eb2xcvXlxS7tmaAAAAgEfBhQsX9PLLL6tq1ap655139Pzzz+vNN9+UJBUpUkSBgYHat2+fEhISJN0K2Zo2baqqVauaIZsk+fr6qk+fPurQoYMkqWLFimrWrJkiIyO1fft2Sf+apAHA/cti3K3jOYBH1qVLl/TSSy8pPj5efn5+MgxDP/30k2w2m/r376/IyEg5OTkpNDTU3CYtLe2ug7oCAAAAD5OzZ8+qQoUKMgxDOTk5dwRfSUlJevfdd3Xp0iW98847ql69ur799lu1bNlSUVFRatKkia5evaoWLVrIx8dHS5YskSRlZWVp9uzZGjNmjH777TdzplI7e3fSI0eOaNq0aRo7dqyeeOKJe3XaAP4HtHgDkEvJkiX15Zdf6pdfftGCBQu0evVqHThwQMeOHVOFChVUs2ZNnTt3TidPnjS3KVSoEBMmAAAA4KE2ffp0derUScePH5fFYjFDt9TUVHMdT09P1alTR59//rl8fHy0b98+hYSEmNtnZ2fLy8tLQ4YMUWhoqC5fvizpVq8Rf39/DRgwwOxJYmez2czupLVq1dKKFSsI3YAHCMEbgDt4eHjIarXKzc1NFotF8+bNU+3atfXkk09q9OjR2rVrlx5//PFc21gsFlmt3FIAAADwcLF3EqtWrZrc3d319ddfS5KWLl2qevXqqUuXLlqzZo3S0tKUL18+9ezZU87OzurVq5d69uypKlWqaOXKldq0aZOio6MlSQEBASpdunSuWUl9fX01b948lSlTJtfxqWMDDzY6hAO4Q1ZWlsLDw7V582bFxMQoNTVV06dPV9myZc1m7jabjUoAAAAAHmo2m005OTnKly+fWrdurYiICEVHR6tEiRJasWKFunXrpv3792vChAlKTEzU0KFD5erqqpUrVyohIUFhYWFq1KiRzp49q8KFC2vFihVq0qSJSpYsqREjRujixYt3HDMnJ+euM6ICeDAxxhuAu4qNjdXSpUv17LPPqkePHnldHAAAAOCe+uOD5vT0dNlsNu3atUtTp05Vamqqxo8frx49eujGjRsaM2aMDh8+rFWrVqls2bJq166dsrKytHXrVknSqlWrNG7cOJ09e1ZxcXHy9fXNy1MDcA/RXAXAXdWtW1dz5swxQzdmKAUAAMCjxGq1KjExUf3791eVKlU0ceJE+fn5qUKFCvrll1/0/PPPS5Lc3NzUunVr5eTkaNmyZZKkdu3aafv27fr0008VEhKikJAQLV26VOHh4blCN8ZJBh5+dDUFcFf2AVztT/qYqhwAAACPkri4OL300kuqUqWKli1bJicnJ3l5ealNmzY6dOiQwsPD9dprr0mSmjRpooiICG3dulWDBg3S66+/riNHjig0NFS//fab3nrrLfn5+d1xDIvFYta7ATyc6GoKAAAAAMBtRo8erePHj2vTpk25ll+6dElBQUGyWq1avny58ufPL0lau3atpk2bpq5du+rNN99UVlaWUlJSVLx48bwoPoD7BF1NAQAAAAC4jYuLi44cOaLdu3drxowZmjp1qoKCgnT+/Hk1btxYly9f1ldffWWu37hxY1WqVEnp6enm9vbQjWFbgEcXLd4AAAAAALjNpUuX9NJLLyk+Pl5+fn4yDEM//fSTbDab+vfvr8jISDk5OSk0NNTcJi0tTYUKFcrDUgO43zBoEwAAAAAAtylZsqS+/PJLFSxYUCkpKfL09JTFYpGrq6sqVKigmjVravv27Tp58qQef/xxSVKhQoVkGIYMwzBnRAXwaKPFGwAAAAAAfyEzM1Ourq6aN2+elixZorVr18rT01MuLi5ydXXN6+IBuI/R4g0AAAAAgLvIyspSeHi4Nm/erJiYGKWmpmr69OkqW7asDMOQxWKRzWajdRuAP0XwBgAAAADAXbi4uKhSpUoqWLCgJk2apB49epjvWSwWSSJ0A/CX6GoKAAAAAMCfsLdss8vOzpazM21YAPx7CN4AAAAAAPg/0KUUwH+D4A0AAAAAAABwAOJ6AAAAAAAAwAEI3gAAAAAAAAAHIHgDAAAAAAAAHIDgDQAAAAAAAHAAgjcAAAAAAADAAQjeAAAAYKpQoYI+/fTT/2kfkyZNUu3atf+W8gAAADzILIZhGHldCAAAANxbS5Ys0YgRI3Tt2rVcy5OSkuTu7i43N7f/et/Xr19XZmamihYt+j+WEgAA4MHmnNcFAAAAwP2jePHi//M+ChYsqIIFC/4Npbm7rKwsubi4OGz/AAAAfxe6mgIAADyAMjMzNWzYMJUoUUL58+dX48aNFRsbK0mKioqSxWLRxo0bVatWLeXPn18NGjTQ0aNHzff79OmjlJQUWSwWWSwWTZo0SdKdXU0tFosWLFigtm3bys3NTTVq1FBMTIx+/PFHNWvWTO7u7mrUqJFOnz5tbnN7V1P7Mf74r0KFCub7R48eVevWrVWwYEGVLFlSgYGBunLlivl+s2bNNGTIEI0YMULFihVTq1at/v7/oQAAAA5A8AYAAPAAevPNN7Vu3TotXbpU33//vapUqaJWrVopOTnZXGfMmDH6+OOPFRsbq+LFi6tdu3a6efOmGjVqpE8//VQeHh66ePGiLl68qNGjR//psd577z298sorOnTokKpXr66ePXtqwIABevvtt3XgwAEZhqEhQ4b86fb2Y1y8eFE//vijqlSpoiZNmkiSrl27Jn9/f/n6+urAgQPasmWLLl26pG7duuXax9KlS+Xi4qI9e/Zo/vz5/+P/PQAAgHuDrqYAAAAPmPT0dM2bN09LlixR69atJUmff/65tm/fri+++ELPPPOMJGnixIlq2bKlpFvBVZkyZRQeHq5u3bqpcOHCslgsKlWq1P95vD59+phBWHBwsBo2bKgJEyaYLc+GDx+uPn36/On29mMYhqHOnTurcOHCWrBggSRpzpw58vX11ZQpU8z1Fy1apLJly+rUqVOqVq2aJKlq1aqaPn36f/T/CQAAIK/R4g0AAOABc/r0ad28eVPPPvusuSxfvnyqV6+eTpw4YS5r2LCh+XeRIkX0+OOP53r/31WrVi3z75IlS0qSfHx8ci3LyMhQamrqX+5n7NixiomJ0ZdffqkCBQpIkg4fPqxdu3aZ48IVLFhQ1atXN8/Trk6dOv9xuQEAAPIaLd4AAADwl/Lly2f+bbFY/nSZzWb7030sX75cn3zyiaKiovTYY4+Zy69fv6527dpp2rRpd2xTunRp8293d/f//gQAAADyCC3eAAAAHjCVK1c2xzuzu3nzpmJjY1WzZk1z2b59+8y/r169qlOnTqlGjRqSJBcXF+Xk5NyT8sbExOi1117TggUL1KBBg1zvPf300zp27JgqVKigKlWq5PpH2AYAAB50BG8AAAAPGHd3dwUFBWnMmDHasmWLjh8/rv79++vGjRvq16+fud7kyZO1c+dOHT16VK+++qqKFSumDh06SLo1e+n169e1c+dOXblyRTdu3HBIWRMTE9WxY0e99NJLatWqlRITE5WYmKikpCRJ0uDBg5WcnKwePXooNjZWp0+f1tatW9WnT597FgwCAAA4CsEbAADAA+jDDz9U586dFRgYqKefflo//vijtm7dKi8vr1zrDB8+XHXq1FFiYqIiIiLk4uIiSWrUqJEGDhyo7t27q3jx4g6buCA+Pl6XLl3S0qVLVbp0afOffQIIb29v7dmzRzk5OXr++efl4+OjESNGyNPTU1YrVVUAAPBgsxiGYeR1IQAAAPD3iYqKUvPmzXX16lV5enrmdXEAAAAeWTxGBAAAAAAAAByA4A0AAAAAAABwALqaAgAAAAAAAA5AizcAAAAAAADAAQjeAAAAAAAAAAcgeAMAAAAAAAAcgOANAAAAAAAAcACCNwAAAAAAAMABCN4AAAAAAAAAByB4AwAAAAAAAByA4A0AAAAAAABwAII3AAAAAAAAwAH+H8yAX0AdCAf3AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\", \"adam\", \"sgd\", \"adagrad\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between convergence times on CIFAR\"\n",
+    "save_path = f\"diagrams/convergence_times_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_convergence(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "841b1f22",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2538760060.py:30: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_diagonal\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between convergence times of shampoo diagonal and non-diagonal on CIFAR10\"\n",
+    "save_path = f\"diagrams/convergence_times_shampoo_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_convergence(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "66dd21fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2538760060.py:30: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABN4AAAMYCAYAAAAU5yoBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC2O0lEQVR4nOzdd3xO9///8eeVkEEkZhIjYtfeK9QesWtV0SKqdEQVNTusaq0Oq6gOq5QqWh9q77ZW1daaUVqC0iR2SN6/P/xyfV0SXBc5jfC43265kfd5X+e8zrnOda7reuac97EZY4wAAAAAAAAAJCu3lC4AAAAAAAAAeBwRvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAGwlM1m05AhQ1K6jCTlyZNHTZo0SekygEdCzZo1VbNmzZQuwzLLly9X6dKl5eXlJZvNpqioqAeeV82aNVW8ePHkK+4xFR8fr+LFi+v9999P6VJwm8qVK6tfv34PNY/jx4/LZrNp+vTp9rYhQ4bIZrM9ZHWPrkdt/ZJ6DlK76dOny2az6fjx4/a2x/296XFfPwC3ELwBFjt69Khefvll5cuXT15eXvL19VXVqlU1btw4Xb16NaXLQzK6cuWKhgwZovXr16d0KUCSDhw4oCFDhjh8qXkSnD9/Xm3atJG3t7c+/fRTzZo1S+nTp0/psh5733zzjU6ePKnu3bundCmPhEflPaJ///769NNPFRkZmaJ1AHg0Xbt2TZ988okqVaokPz8/eXl5qVChQurevbsOHTpk75cQRv/zzz/2trCwMNlstiR/li9f7rCcNm3ayGazqX///knWsX79eofHu7u7y9/fX61bt9bvv/+eqP/BgwfVq1cvValSxf5Htnt93lm8eLHKli0rLy8v5c6dW4MHD9bNmzdd3FqAc9KkdAHA42zp0qV69tln5enpqY4dO6p48eKKjY3VTz/9pL59+2r//v2aOnVqSpdpqatXrypNmifjUHPlyhUNHTpUkvjrJR5JBw4c0NChQ1WzZk3lyZPHYdrKlStTpqj/wPbt23Xx4kW99957qlu3bkqX88QYM2aM2rZtKz8/v5Qu5ZHwqLxHPPPMM/L19dWkSZM0bNiwZJvvO++8owEDBiTb/ADp8X5vehT9888/atCggXbs2KEmTZqoffv28vHx0cGDBzV37lxNnTpVsbGx95yHp6envvjii0TtpUqVsv8/JiZG//vf/5QnTx598803Gjly5F3PKO3Ro4cqVKigGzduaM+ePZoyZYrWr1+vffv2KTAw0N5v8+bNGj9+vIoWLaoiRYpo165dd61x2bJlat68uWrWrKkJEyZo7969Gj58uM6ePavJkyffZysBrnsyvg0DKSAiIkJt27ZVcHCw1q5dq+zZs9unhYeH68iRI1q6dGkKVmid+Ph4xcbGysvLS15eXildDnBfxhhdu3ZN3t7eKV1KivHw8EjpEixz9uxZSVLGjBlTtpAnyM6dO7V792599NFHKV0K7uDm5qbWrVtr5syZGjp0aLJdPpkmTZon5g9t+O88zu9Nj6KwsDDt3LlT3333nVq1auUw7b333tPbb79933mkSZNGL7zwwj37LFiwQHFxcfrqq69Uu3Ztbdy4UTVq1Eiyb7Vq1dS6dWv770899ZReffVVzZw50+Gy+WbNmikqKkoZMmTQhx9+eM/grU+fPipZsqRWrlxpP275+vrqgw8+0BtvvKHChQvfdz0BV3CpKWCR0aNH69KlS/ryyy8dQrcEBQoU0BtvvGH//ebNm3rvvfeUP39+eXp6Kk+ePHrrrbd0/fp1h8cljEu2fv16lS9fXt7e3ipRooT90pWFCxeqRIkS8vLyUrly5bRz506Hx4eFhcnHx0fHjh1TaGio0qdPrxw5cmjYsGEyxjj0/fDDD1WlShVlyZJF3t7eKleunL777rtE62Kz2dS9e3fNnj1bxYoVk6enp/108jvHeLt48aJ69uypPHnyyNPTU/7+/qpXr55+++03h3nOnz9f5cqVk7e3t7JmzaoXXnhBf//9d5Lr8vfff6t58+by8fFRtmzZ1KdPH8XFxd3lmUls5cqV9rGfihYtqoULFybqExUVpZ49eyooKEienp4qUKCARo0apfj4eEm3xlrJli2bJNm/yCSs++LFi2Wz2bRnzx77/BYsWCCbzaaWLVs6LKdIkSJ67rnnHNq+/vpr+7bInDmz2rZtq5MnTyaqcevWrWrQoIH8/PyULl061ahRQz///LNDn4TLAo4cOaKwsDBlzJhRfn5+6ty5s65cueLU9tq6dasaNWqkTJkyKX369CpZsqTGjRvn0Gft2rWqVq2a0qdPr4wZM+qZZ55JdFmAs7UUL15ctWrVSlRHfHy8cubM6fBhLD4+XmPHjlWxYsXk5eWlgIAAvfzyy/r3338dHpvwOlqxYoX9dfTZZ59Jkv788081a9ZM6dOnl7+/v3r16qUVK1bIZrMlukTMim3+9ddfq2LFikqXLp0yZcqk6tWrJ/qL/7Jly+zbN0OGDGrcuLH279+faF63mz59up599llJUq1atez7aMI63TnOTMIlHt9++62GDh2qnDlzKkOGDGrdurWio6N1/fp19ezZU/7+/vLx8VHnzp0THa8S1ud+++/hw4fVqlUrBQYGysvLS7ly5VLbtm0VHR19z3WS7n+sqFmzpjp16iRJqlChgmw2m8LCwu46P2ePUdKtMwhr1aqldOnSKWfOnBo9erTD9NjYWA0aNEjlypWTn5+f0qdPr2rVqmndunUO/RLGavrwww/16aefKl++fEqXLp3q16+vkydPyhij9957T7ly5ZK3t7eeeeYZXbhwwWEeCfu0M8ezY8eO6dlnn1XmzJmVLl06Va5cOck/BJ09e1ZdunRRQECAvLy8VKpUKc2YMeOu2+5233//vTw8PFS9enWH9oTXw6FDh/TCCy/Iz89P2bJl07vvvitjjE6ePGk/IyswMDDJ4M6ZupJjm0rOvdaceS+613uEdPdxnsLCwhzOTk2u9apXr57+/PPPe34xTRAVFaWwsDD5+fkpY8aM6tSpU5JjJCY1Btq0adNUu3Zt+fv7y9PTU0WLFk3ybJL4+HgNGTJEOXLkULp06VSrVi0dOHBAefLkSfR6dWb/vf349f777ytXrlzy8vJSnTp1dOTIEYe+mzZt0rPPPqvcuXPL09NTQUFB6tWr1wMPB+Ls/Fz5DOPsc5CUhHHTfv75Z/Xu3VvZsmVT+vTp1aJFC507dy5R/0mTJtk/y+XIkUPh4eGJlpUwzuX9joH3sn//ftWuXVve3t7KlSuXhg8fbv9Mdeeybn9tOHtclW4NM9ChQwf5+vrat9vu3buTHBsvOT+3SM7v+85y9XvCTz/9pIoVK8rLy0v58uXTzJkz77uMrVu3aunSperSpUui0E26dSbbhx9++MDrcLvZs2erXr16qlWrlooUKaLZs2c7/dhq1apJujWcz+0yZ86sDBky3PfxBw4c0IEDB9StWzeHPxa89tprMsYk+V0HeGgGgCVy5sxp8uXL53T/Tp06GUmmdevW5tNPPzUdO3Y0kkzz5s0d+gUHB5unnnrKZM+e3QwZMsR88sknJmfOnMbHx8d8/fXXJnfu3GbkyJFm5MiRxs/PzxQoUMDExcU5LMfLy8sULFjQdOjQwUycONE0adLESDLvvvuuw7Jy5cplXnvtNTNx4kTz8ccfm4oVKxpJZsmSJQ79JJkiRYqYbNmymaFDh5pPP/3U7Ny50z5t8ODB9r7t27c3Hh4epnfv3uaLL74wo0aNMk2bNjVff/21vc+0adOMJFOhQgXzySefmAEDBhhvb2+TJ08e8++//yZal2LFipkXX3zRTJ482bRq1cpIMpMmTbrvNg8ODjaFChUyGTNmNAMGDDAff/yxKVGihHFzczMrV66097t8+bIpWbKkyZIli3nrrbfMlClTTMeOHY3NZjNvvPGGMcaYS5cumcmTJxtJpkWLFmbWrFlm1qxZZvfu3eb8+fPGZrOZCRMm2Of5xhtvGDc3N5MtWzZ729mzZ40kM3HiRHvb8OHDjc1mM88995yZNGmSGTp0qMmaNWuibbFmzRrj4eFhQkJCzEcffWQ++eQTU7JkSePh4WG2bt1q7zd48GAjyZQpU8a0bNnSTJo0ybz00ktGkunXr999t9nKlSuNh4eHCQ4ONoMHDzaTJ082PXr0MHXr1rX3WbVqlUmTJo0pVKiQGT16tL3mTJkymYiICJdrGTZsmHFzczOnT592qGXDhg1Gkpk/f7697aWXXjJp0qQxXbt2NVOmTDH9+/c36dOnNxUqVDCxsbEOz32BAgVMpkyZzIABA8yUKVPMunXrzKVLl0y+fPmMt7e3GTBggBk7dqypWLGiKVWqlJFk1q1bZ+k2HzJkiJFkqlSpYsaMGWPGjRtn2rdvb/r372/vM3PmTGOz2UyDBg3MhAkTzKhRo0yePHlMxowZHbbvnY4ePWp69OhhJJm33nrLvo9GRkYaY4ypUaOGqVGjhr3/unXrjCRTunRpExISYsaPH2969OhhbDabadu2rWnfvr1p2LCh+fTTT02HDh2MJDN06FCHZTqz/16/ft3kzZvX5MiRwwwfPtx88cUXZujQoaZChQrm+PHjd10fY5w7VqxcudJ069bNSDLDhg0zs2bNMr/88std5+nMMapGjRomR44cJigoyLzxxhtm0qRJpnbt2kaS+fHHH+39zp07Z7Jnz2569+5tJk+ebEaPHm2eeuopkzZtWvsx0hhjIiIi7Nu6aNGi5uOPPzbvvPOO8fDwMJUrVzZvvfWWqVKlisNz0LlzZ4e6nT2eRUZGmoCAAJMhQwbz9ttvm48//tiUKlXKuLm5mYULF9r7XblyxRQpUsSkTZvW9OrVy4wfP95Uq1bNSDJjx4695/NijDF169Y1ZcuWTdSe8HooXbq0adeunZk0aZJp3LixkWQ+/vhj89RTT5lXX33VTJo0yVStWtVIMhs2bHC5ruTYps6+1px5L7rXe0TCPnX76+/2eQcHByfrehljzF9//WUkObwvJSU+Pt5Ur17duLm5mddee81MmDDB1K5d25QsWdJIMtOmTUv03N6uQoUKJiwszHzyySdmwoQJpn79+one54wxpl+/fkaSadq0qZk4caLp2rWryZUrl8maNavp1KmTvZ+z+2/C8atMmTKmXLly5pNPPjFDhgwx6dKlMxUrVnRY9uuvv24aNWpkPvjgA/PZZ5+ZLl26GHd3d9O6dWuHfkmtX1KcnZ+zn2FceQ6SknCcLFOmjKldu7aZMGGCefPNN427u7tp06ZNkutYt25dM2HCBNO9e3fj7u6e6D3U2WPg3Zw+fdpky5bNZMqUyQwZMsSMGTPGFCxY0L5Ot7++7nxtOHtcjYuLMyEhIcbd3d10797dTJw40dSrV8/+fn77dkvuzy3GOL/v3+21fydXvycEBASYt956y0ycONGULVvW2Gw2s2/fvnsu46233jKSzMaNG+9bz+3b49y5cw51pk+f3pw7d87hJyoqyt7n77//Nm5ubmbWrFnGmFuf8zJlymSuX7/uMP+E1/Htn/OMMWbJkiVGksNnozuNGTMm0b6U4OuvvzaSHD6rJciVK5dp2bKlU+sPuILgDbBAdHS0kWSeeeYZp/rv2rXLSDIvvfSSQ3ufPn2MJLN27Vp7W3BwsJHk8MVxxYoVRpLx9vY2f/75p739s88+SxQWJLxxv/766/a2+Ph407hxY+Ph4eHw5nnlyhWHemJjY03x4sVN7dq1HdolGTc3N7N///5E63Zn8Obn52fCw8Pvui1iY2ONv7+/KV68uLl69aq9PeFNdtCgQYnWZdiwYQ7zSPigfT8J23LBggX2tujoaJM9e3ZTpkwZe9t7771n0qdPbw4dOuTw+AEDBhh3d3dz4sQJY8ytD4N3rm+CYsWKOXzALVu2rHn22WeNJPP7778bY4xZuHChkWT/Inb8+HHj7u5u3n//fYd57d2716RJk8beHh8fbwoWLGhCQ0NNfHy8vd+VK1dM3rx5Tb169extCR+SXnzxRYd5tmjRwmTJkuWe2+vmzZsmb968Jjg42CH0S6ghQenSpY2/v785f/68vW337t3Gzc3NdOzY0eVaDh48mOQXxNdee834+PjY99NNmzYZSWb27NkO/ZYvX56oPeG5X758uUPfjz76yEgy33//vb3t6tWrpnDhwg6vJSu2+eHDh42bm5tp0aKFQ1iesDxjjLl48aLJmDGj6dq1q8P0yMhI4+fnl6j9TvPnz090TEhwt+CtePHiDl+42rVrZ2w2m2nYsKHD40NCQhwCAmf33507dyb5wfp+XDlWJHzx3L59+33ne79jlDG3tpUkM3PmTHvb9evXTWBgoGnVqpW97ebNm4m+SPz7778mICDAYX9ICFOyZcvm8OVk4MCBRpIpVaqUuXHjhr29Xbt2xsPDw1y7ds3e5uzxrGfPnkaS2bRpk73t4sWLJm/evCZPnjz2fW/s2LFGkkPgGBsba0JCQoyPj4+JiYm55zbKlSuXw7ZIkPB66Natm8N2ypUrl7HZbGbkyJEO28rb29sheHG2rofdpq681px9L7rXe4SrwdvD7CsJPDw8zKuvvpqo/Xbff/+9kWRGjx5tb7t586Y97Lxf8Hbn5whjjAkNDXX4w2RkZKRJkyZNogAh4Q8Rtz//zu6/CcevIkWKOLwGx40bZySZvXv33rPGESNGGJvN5vCZytngzdn5ObvfuPIcJCXh+Fe3bl2H96tevXoZd3d3+3509uxZ4+HhYerXr+/wHjRx4kQjyXz11Vf2NmePgXeT8DzeHnycPXvW+Pn53Td4c/a4umDBgkSBfFxcnD0gvH27JffnFmOc2/eTWr+kPMj3hNvDs7NnzxpPT0/z5ptv3nM5LVq0MJISfca7m7sFb5IS/dy+jh9++KHx9va2H68PHTpkJJlFixY5zD/hdfzVV1+Zc+fOmVOnTpnly5ebAgUKGJvNZrZt23bX2u4VvCVMS/j8frsKFSqYypUrO7X+gCu41BSwQExMjCQ5dbqzJP3444+SpN69ezu0v/nmm5KU6BKKokWLKiQkxP57pUqVJEm1a9dW7ty5E7UfO3Ys0TJvv8tcwqWisbGxWr16tb399vGu/v33X0VHR6tatWpJXnJVo0YNFS1a9D5remuMpa1bt+rUqVNJTv/111919uxZvfbaaw7jwzVu3FiFCxdO8nKoV155xeH3atWqJbnOScmRI4datGhh/93X11cdO3bUzp077Xd8mz9/vqpVq6ZMmTLpn3/+sf/UrVtXcXFx2rhx432XU61aNW3atEnSrUvZdu/erW7duilr1qz29k2bNiljxowqXry4pFuXDcfHx6tNmzYOyw0MDFTBggXtl1Xs2rVLhw8fVvv27XX+/Hl7v8uXL6tOnTrauHFjoss3ktpm58+ft++7Sdm5c6ciIiLUs2fPRGNlJVxedPr0ae3atUthYWHKnDmzfXrJkiVVr149+77uSi2FChVS6dKlNW/ePHufuLg4fffdd2ratKl9P50/f778/PxUr149h+1Vrlw5+fj4JLoMJW/evAoNDXVoW758uXLmzKlmzZrZ27y8vNS1a1eHflZs8++//17x8fEaNGiQ3Nwc354Ttu+qVasUFRWldu3aOayju7u7KlWqlOSlNg+rY8eOSps2rf33SpUqyRijF1980aFfpUqVdPLkSfsdwZzdfxMG3l+xYoXTlztLD3ascMb9jlEJfHx8HMaw8fDwUMWKFR2OPe7u7vbxieLj43XhwgXdvHlT5cuXT/I4+uyzzzrciCDhGP7CCy84XA5TqVIlxcbGJrr83pnj2Y8//qiKFSvq6aefdliXbt266fjx4zpw4IC9X2BgoNq1a2fvlzZtWvXo0UOXLl3Shg0b7rl9zp8/r0yZMt11+ksvvWT/v7u7u8qXLy9jjLp06WJvz5gxo5566imHbepqXQ+6TR/ktfYw70Wueth9RZL9Pe1efvzxR6VJk0avvvqqvc3d3V2vv/66U3Xe/jkiOjpa//zzj2rUqKFjx47ZLyVfs2aNbt68qddee83hsUktw9n9N0Hnzp0dxghLuETt9ufl9hovX76sf/75R1WqVJExJtFwHa6uszPzu99+87DPQYJu3bo5XApcrVo1xcXF6c8//5QkrV69WrGxserZs6fDe1DXrl3l6+ub6JjqzDHwbn788UdVrlxZFStWtLdly5ZNzz///H0f6+xxdfny5UqbNq3D+7ebm5vCw8Md5mfF5xbJuX3fWQ/yPSFhX5dubds7j6VJcfX7y914eXlp1apVDj+3Dxswe/ZsNW7c2L6cggULqly5cne93PTFF19UtmzZlCNHDjVo0EDR0dGaNWuWKlSo8ED1JVz27enpmWTtD3qZOXAvjIAKWMDX11fSrYDFGX/++afc3NxUoEABh/bAwEBlzJjR/qEowe3hmvR/X1yDgoKSbL9zfCs3Nzfly5fPoa1QoUKS5HDb7SVLlmj48OHatWuXwxgSSQ3EnDdv3ruu3+1Gjx6tTp06KSgoSOXKlVOjRo3UsWNHez0J6/rUU08lemzhwoX1008/ObR5eXnZx81JkClTpkTrfDcFChRItD63b4vAwEAdPnxYe/bsSbScBAkDt99LtWrVNGXKFB05ckRHjx6VzWZTSEiIPZDr2rWrNm3apKpVq9o/8B4+fFjGGBUsWDDJeSaEIYcPH5Yk+zhWSYmOjnb4EnznPpQw7d9//7Xvv3dKGEsjIRhMyr2evyJFimjFihW6fPmy0qdP71Itzz33nN566y39/fffypkzp9avX6+zZ886jId3+PBhRUdHy9/fP8na7nyektpn//zzT+XPnz/RPnHna9OKbX706FG5ubndM8BOWG7t2rWTnH635+5huHK8iY+PV3R0tLJkyeL0/ps3b1717t1bH3/8sWbPnq1q1aqpWbNm9vG/7sbVY4Wz7neMSpArV65E+0mmTJkcxnKUpBkzZuijjz7SH3/8oRs3btjbk9r/HvbY7szx7M8//7SHNLcrUqSIpFvbtXjx4vrzzz9VsGDBRCHw7f3ux9wxbujtklpXLy8vZc2aNVH7+fPn7b+7WteDblNXX2sP+17kqofdV6Rbz8/9bqzw559/Knv27PLx8XFoT+p1l5Sff/5ZgwcP1ubNmxMF69HR0fLz87M/Z3ceZzNnzpwovHV2/01wr+NughMnTmjQoEFavHhxou3kakDi6vyc2W8e9jlIcL9tcbdjqoeHh/Lly5foteXMMTAh8E/g5+cnb2/vuz6Pzq6TM8fVhO2WLl06h8feuZ9Z9bnFmX3fWQ/7PSGhxvsdj27//vIwNyNyd3e/6x3Ef//9d+3cuVMdO3Z0GG+xZs2a+vTTTxUTE5Po+Dpo0CBVq1ZNly5d0qJFizR37txE7wGuSAhFkxqX9km/0RasQ/AGWMDX11c5cuTQvn37XHqcs3cWc3d3d6n9Xl9+7mbTpk1q1qyZqlevrkmTJil79uxKmzatpk2bpjlz5iTq7+ybVJs2bVStWjUtWrRIK1eu1JgxYzRq1CgtXLhQDRs2dLnOu61zcoqPj1e9evUc7px0u4QvtveS8Nf5jRs36tixYypbtqx9QODx48fr0qVL2rlzp95//32H5dpsNi1btizJ9Uz4EJ5wZtWYMWNUunTpJJd/5wf25NxXHpYztTz33HMaOHCg5s+fr549e+rbb7+Vn5+fGjRoYO8THx8vf3//u/7F9M4vNw/zwSqltnnCcmfNmqXAwMBE0624o+CDHm+c3X8l6aOPPlJYWJh++OEHrVy5Uj169NCIESO0ZcsW5cqVKxnWwnnOHqOceT6//vprhYWFqXnz5urbt6/8/f3l7u6uESNGJBoU+l7zfJRer87KkiXLPb/kJbVOVqznw+y/kvOvtYd9L7LZbEmu591uFJQc+0pUVFSioDM5HT16VHXq1FHhwoX18ccfKygoSB4eHvrxxx/1ySefJDmQfnK73/aIi4tTvXr1dOHCBfXv31+FCxdW+vTp9ffffyssLMzlGl2d33/xGeZ+y3rQ15cz87vz5mLTpk27581tnOHqcdUK91t3q/b9h/2ecL/nOuFOnnv37nU4Yy45ff3115KkXr16qVevXommL1iwQJ07d3ZoK1GihD3Ia968ua5cuaKuXbvq6aefTvTHBmck7JenT59O9PjTp087nIkJJBeCN8AiTZo00dSpU7V582aHy0KTEhwcrPj4eB0+fNj+V1tJOnPmjKKiohQcHJystcXHx+vYsWMOgdGhQ4ckyX73tAULFsjLy0srVqxwOBV72rRpD7387Nmz67XXXtNrr72ms2fPqmzZsnr//ffVsGFD+7oePHgw0ZkGBw8eTPZtceTIkUR/9b9zW+TPn1+XLl2661/vEtzrA1Hu3LmVO3dubdq0SceOHbN/oKlevbp69+6t+fPnKy4uzuEOgPnz55cxRnnz5r1nuJc/f35JtwLf+9X4MBKWs2/fvrsu5/bn705//PGHsmbN6vBXY2flzZtXFStW1Lx589S9e3ctXLhQzZs3d9g38+fPr9WrV6tq1aoPHKoFBwfrwIEDifaJO++CZ8U2z58/v+Lj43XgwIG7hnkJy/X393+g5Tr7oT05OLv/JihRooRKlCihd955R7/88ouqVq2qKVOmaPjw4Un2t/JYca9jlCu+++475cuXTwsXLnTY9oMHD37g2u7FmeNZcHDwXV+fCdMT/t2zZ4/i4+Mdziy4s9/dFC5cWBEREQ++MnfxsHU562Ffa0m51+svU6ZMSV4G5syZhQ/i77//VmxsrMNnjqQEBwdrzZo1unTpkkNYntQ+dKf//e9/un79uhYvXuxwBs6dl+kmPGdHjhxxOGPp/PnzicJbZ/dfZ+3du1eHDh3SjBkz1LFjR3v7qlWrXJqPVfOTHu45cHU5CfO9/Qzf2NhYRUREPNDr4M71LlasmH1ZCWeV3s6ZdXL2uBocHKx169bpypUrDme93fl+bsXnFmf3fWf9V98TmjZtqhEjRujrr7+2JHgzxmjOnDmqVatWokvLJem9997T7NmzEwVvdxo5cqQWLVqk999/X1OmTHG5joTPWL/++qtDyHbq1Cn99ddf6tatm8vzBO6HMd4Ai/Tr10/p06fXSy+9pDNnziSafvToUY0bN06S1KhRI0nS2LFjHfp8/PHHkm6NWZTcJk6caP+/MUYTJ05U2rRpVadOHUm3/lpms9kc/tp+/Phxff/99w+8zLi4uESXWfj7+ytHjhz2073Lly8vf39/TZkyxeEU8GXLlun3339P9m1x6tQpLVq0yP57TEyMZs6cqdKlS9vPcmjTpo02b96sFStWJHp8VFSUfUyrhA92UVFRSS6rWrVqWrt2rbZt22b/QFO6dGllyJBBI0eOlLe3t8qVK2fv37JlS7m7u2vo0KGJ/kppjLFfflWuXDnlz59fH374oS5dupRouefOnXN2c9xT2bJllTdvXo0dOzbROibUlz17dpUuXVozZsxw6LNv3z6tXLnSvq8/iOeee05btmzRV199pX/++cfhMlPp1vMUFxen9957L9Fjb968edfn5XahoaH6+++/tXjxYnvbtWvX9Pnnnzv0s2KbN2/eXG5ubho2bFiiv4YnbN/Q0FD5+vrqgw8+cLi8xtnlJnx5cGZbPCxn99+YmBj7ayhBiRIl5ObmluRlIAmsOFY4c4xyRcJZB7ev/9atW7V582aX5+UMZ45njRo10rZt2xxquHz5sqZOnao8efLYL3Vu1KiRIiMjHcZWvHnzpiZMmCAfHx/VqFHjnrWEhIRo3759D7Td7uVh63LWw77WknKv94j8+fPrjz/+cJjv7t279fPPP7u8HGfs2LFDklSlSpV79mvUqJFu3rypyZMn29vi4uI0YcKE+y4jqf0/Ojo60R/w6tSpozRp0jgsQ3L8nHJ7Pc7sv85KqkZjjP3zmauSe37Swz0Hrqhbt648PDw0fvx4h/q//PJLRUdHP9AxtW7dug4/CWcaNWrUSFu2bNG2bdvsfc+dO3fXM9Zv5+xxNTQ0VDdu3HB4/46Pj9enn37q0M+Kzy3O7vvO+q++J4SEhKhBgwb64osvkvy8Hxsbqz59+jzw/H/++WcdP35cnTt3VuvWrRP9PPfcc1q3bt19x1jNnz+/WrVqpenTpye6nNkZxYoVU+HChTV16lSH7zmTJ0+WzWZT69atXZ4ncD+c8QZYJH/+/JozZ46ee+45FSlSRB07dlTx4sUVGxurX375RfPnz7efbl+qVCl16tRJU6dOVVRUlGrUqKFt27ZpxowZat68uWrVqpWstXl5eWn58uXq1KmTKlWqpGXLlmnp0qV666237JfjNW7cWB9//LEaNGig9u3b6+zZs/r0009VoECBRGMYOevixYvKlSuXWrdurVKlSsnHx0erV6/W9u3b7YOupk2bVqNGjVLnzp1Vo0YNtWvXTmfOnNG4ceOUJ0+eJE9LfxiFChVSly5dtH37dgUEBOirr77SmTNnHD4c9e3bV4sXL1aTJk0UFhamcuXK6fLly9q7d6++++47HT9+XFmzZpW3t7eKFi2qefPmqVChQsqcObOKFy9uH2+mWrVqmj17tmw2m/3SU3d3d1WpUkUrVqxQzZo1HQaBzp8/v4YPH66BAwfq+PHjat68uTJkyKCIiAgtWrRI3bp1U58+feTm5qYvvvhCDRs2VLFixdS5c2flzJlTf//9t9atWydfX1/973//e+ht5ebmpsmTJ6tp06YqXbq0OnfurOzZs+uPP/7Q/v377cHkmDFj1LBhQ4WEhKhLly66evWqJkyYID8/Pw0ZMuSBl9+mTRv16dNHffr0UebMmRP99b1GjRp6+eWXNWLECO3atUv169dX2rRpdfjwYc2fP1/jxo2774epl19+WRMnTlS7du30xhtvKHv27Jo9e7Z98P6Ev65bsc0LFCigt99+W++9956qVaumli1bytPTU9u3b1eOHDk0YsQI+fr6avLkyerQoYPKli2rtm3bKlu2bDpx4oSWLl2qqlWrJvllNUHp0qXl7u6uUaNGKTo6Wp6enqpdu/Zdx8V7GM7uv2vXrlX37t317LPPqlChQrp586ZmzZold3d3tWrV6q7zt+JY4cwxyhVNmjTRwoUL1aJFCzVu3FgRERGaMmWKihYtmmRg+7CcOZ4NGDBA33zzjRo2bKgePXooc+bMmjFjhiIiIrRgwQL7WWTdunXTZ599prCwMO3YsUN58uTRd999p59//lljx4697+DbzzzzjN577z1t2LBB9evXT7Z1fNi6nPWwr7Wk3Os94sUXX9THH3+s0NBQdenSRWfPntWUKVNUrFixe9705kGtWrVKuXPnVpkyZe7Zr2nTpqpataoGDBig48ePq2jRolq4cKFTY5/Vr19fHh4eatq0qV5++WVdunRJn3/+ufz9/XX69Gl7v4CAAL3xxhv66KOP1KxZMzVo0EC7d+/WsmXLlDVrVoezmpzdf51VuHBh5c+fX3369NHff/8tX19fLViw4IHH5kvu+UkP9xy4Ilu2bBo4cKCGDh2qBg0aqFmzZjp48KAmTZqkChUqONxI4WH169dPs2bNUoMGDfTGG28offr0mjp1qv2M1ntx9rjavHlzVaxYUW+++aaOHDmiwoULa/Hixbpw4YIkxzNQk/tzi7P7vrP+y+8JM2fOVP369dWyZUs1bdpUderUUfr06XX48GHNnTtXp0+f1ocffvhA8549e7bc3d3vGhQ2a9ZMb7/9tubOnZvoRhJ36tu3r7799luNHTtWI0eOlHQr3EwIpBP+aDFx4kRlzJhRGTNmdLix3JgxY9SsWTPVr19fbdu21b59+zRx4kS99NJL9z0TGHggVtwqFcD/OXTokOnatavJkyeP8fDwMBkyZDBVq1Y1EyZMMNeuXbP3u3Hjhhk6dKjJmzevSZs2rQkKCjIDBw506GPMrduEN27cONFyJJnw8HCHtoiICCPJjBkzxt7WqVMnkz59enP06FFTv359ky5dOhMQEGAGDx7scPt4Y4z58ssvTcGCBY2np6cpXLiwmTZtmv3W4fdb9u3TBg8ebIy5dav5vn37mlKlSpkMGTKY9OnTm1KlSplJkyYlety8efNMmTJljKenp8mcObN5/vnnzV9//eXQJ2Fd7pRUjUlJ2JYrVqwwJUuWtK/n/PnzE/W9ePGiGThwoClQoIDx8PAwWbNmNVWqVDEffvihiY2Ntff75ZdfTLly5YyHh4fDuhtjzP79+40kU6RIEYd5Dx8+3Egy7777bpJ1LliwwDz99NMmffr0Jn369KZw4cImPDzcHDx40KHfzp07TcuWLU2WLFmMp6enCQ4ONm3atDFr1qxJtG1uv/W7McZMmzbtrrddv9NPP/1k6tWrZ38OS5YsaSZMmODQZ/Xq1aZq1arG29vb+Pr6mqZNm5oDBw449HmQWqpWrWokmZdeeumu9U2dOtWUK1fOeHt7mwwZMpgSJUqYfv36mVOnTtn73O11ZIwxx44dM40bNzbe3t4mW7Zs5s033zQLFiwwksyWLVsc+lqxzb/66iv7vp8pUyZTo0YNs2rVKoc+69atM6GhocbPz894eXmZ/Pnzm7CwMPPrr7/edbsk+Pzzz02+fPmMu7u7kWTWrVtnjDGmRo0apkaNGg7LkJTo9ZBQ9/bt2x3a77ae99t/jx07Zl588UWTP39+4+XlZTJnzmxq1aplVq9efd91Mca5Y8Xdar6Ts8eoGjVqmGLFiiV6fKdOnUxwcLD99/j4ePPBBx+Y4OBg4+npacqUKWOWLFmSqF9Sx2pjXHsOXDmeHT161LRu3dpkzJjReHl5mYoVK5olS5Yk6nfmzBnTuXNnkzVrVuPh4WFKlChhpk2bdq9N6KBkyZKmS5cuDm1320/udjxPals7U1dybNOE/vd7rbnyXnSv94ivv/7a5MuXz3h4eJjSpUubFStWWLKvxMXFmezZs5t33nknUc1JOX/+vOnQoYPx9fU1fn5+pkOHDmbnzp1GksN2T2p9Fy9ebEqWLGm8vLxMnjx5zKhRo8xXX32V6Nh38+ZN8+6775rAwEDj7e1tateubX7//XeTJUsW88orrzjM05n9927bI2H73V73gQMHTN26dY2Pj4/JmjWr6dq1q9m9e7dT65cUZ+fnyn7j7HOQlHvt27e/BySYOHGiKVy4sEmbNq0JCAgwr776qvn3338d+jh7DLyXPXv2mBo1ahgvLy+TM2dO895775kvv/wy0b5x53uTs8dVY4w5d+6cad++vcmQIYPx8/MzYWFh5ueffzaSzNy5cx36JvfnFmf3/TvX724e9nuCs8sxxpgrV66YDz/80FSoUMH4+PgYDw8PU7BgQfP666+bI0eO3HN73G2/jo2NNVmyZDHVqlW757Lz5s1rypQpY4y5++s4Qc2aNY2vr6+Jiooyxvzf6zupn6T2y0WLFpnSpUsbT09PkytXLvPOO+84fKYHkpPNmEd4ZF4AyS4sLEzfffedJWdbAI+rsWPHqlevXvrrr7+UM2fOlC4HSCRPnjwqXry4lixZktKl2M2aNUvh4eE6ceLEQ90hD8nr+++/V/v27XX06NFEg98/SqKiopQpUyYNHz5cb7/9dkqXg8fE999/rxYtWuinn35S1apVU7ocAE8IxngDAOA2V69edfj92rVr+uyzz1SwYEFCN8AFzz//vHLnzp1oTCWkrFGjRql79+6PVOh253FX+r/xrGrWrPnfFoPHxp37VcLYeL6+vipbtmwKVQXgScQYbwAA3KZly5bKnTu3SpcurejoaH399df6448/nBr0GcD/cXNz0759+1K6DNzBqpt7PIx58+Zp+vTpatSokXx8fPTTTz/pm2++Uf369TkrCQ/s9ddf19WrVxUSEqLr169r4cKF+uWXX/TBBx888N3PAeBBELwBAHCb0NBQffHFF5o9e7bi4uJUtGhRzZ07N9FdVAEAyaNkyZJKkyaNRo8erZiYGPsNF4YPH57SpSEVq127tj766CMtWbJE165dU4ECBTRhwgSHQfYB4L/AGG8AAAAAAACABRjjDQAAAAAAALAAwRsAAAAAAABgAcZ4c0J8fLxOnTqlDBkyyGazpXQ5AAAAAAAASEHGGF28eFE5cuSQm9vdz2sjeHPCqVOnFBQUlNJlAAAAAAAA4BFy8uRJ5cqV667TCd6ckCFDBkm3Nqavr28KVwMAAAAAAICUFBMTo6CgIHtmdDcEb05IuLzU19eX4A0AAAAAAACSdN8hybi5AgAAAAAAAGCBFA3eJk+erJIlS9rPJAsJCdGyZcvs069du6bw8HBlyZJFPj4+atWqlc6cOeMwjxMnTqhx48ZKly6d/P391bdvX928edOhz/r161W2bFl5enqqQIECmj59+n+xegAAAAAAAHiCpWjwlitXLo0cOVI7duzQr7/+qtq1a+uZZ57R/v37JUm9evXS//73P82fP18bNmzQqVOn1LJlS/vj4+Li1LhxY8XGxuqXX37RjBkzNH36dA0aNMjeJyIiQo0bN1atWrW0a9cu9ezZUy+99JJWrFjxn68vAAAAAAAAnhw2Y4xJ6SJulzlzZo0ZM0atW7dWtmzZNGfOHLVu3VqS9Mcff6hIkSLavHmzKleurGXLlqlJkyY6deqUAgICJElTpkxR//79de7cOXl4eKh///5aunSp9u3bZ19G27ZtFRUVpeXLlydZw/Xr13X9+nX77wkD5kVHRzPGGwAAAAAAwBMuJiZGfn5+982KHpkx3uLi4jR37lxdvnxZISEh2rFjh27cuKG6deva+xQuXFi5c+fW5s2bJUmbN29WiRIl7KGbJIWGhiomJsZ+1tzmzZsd5pHQJ2EeSRkxYoT8/PzsP0FBQcm5qgAAAAAAAHgCpHjwtnfvXvn4+MjT01OvvPKKFi1apKJFiyoyMlIeHh7KmDGjQ/+AgABFRkZKkiIjIx1Ct4TpCdPu1ScmJkZXr15NsqaBAwcqOjra/nPy5MnkWFUAAAAAAAA8QdKkdAFPPfWUdu3apejoaH333Xfq1KmTNmzYkKI1eXp6ytPTM0VrAAAAAAAAQOqW4sGbh4eHChQoIEkqV66ctm/frnHjxum5555TbGysoqKiHM56O3PmjAIDAyVJgYGB2rZtm8P8Eu56enufO++EeubMGfn6+srb29uq1QIAAAAAAMATLsUvNb1TfHy8rl+/rnLlyilt2rRas2aNfdrBgwd14sQJhYSESJJCQkK0d+9enT171t5n1apV8vX1VdGiRe19bp9HQp+EeQAAAAAAAABWSNEz3gYOHKiGDRsqd+7cunjxoubMmaP169drxYoV8vPzU5cuXdS7d29lzpxZvr6+ev311xUSEqLKlStLkurXr6+iRYuqQ4cOGj16tCIjI/XOO+8oPDzcfqnoK6+8ookTJ6pfv3568cUXtXbtWn377bdaunRpSq46AAAAAAAAHnMpGrydPXtWHTt21OnTp+Xn56eSJUtqxYoVqlevniTpk08+kZubm1q1aqXr168rNDRUkyZNsj/e3d1dS5Ys0auvvqqQkBClT59enTp10rBhw+x98ubNq6VLl6pXr14aN26ccuXKpS+++EKhoaH/+foCAAAAAADgyWEzxpiULuJRFxMTIz8/P0VHR8vX1zelywEAAAAAAEAKcjYreuTGeAMAAAAAAAAeBwRvAAAAAAAAgAUI3gAAAAAAD2XEiBGqUKGCMmTIIH9/fzVv3lwHDx506BMZGakOHTooMDBQ6dOnV9myZbVgwQKHPr/99pvq1aunjBkzKkuWLOrWrZsuXbpkn37+/Hk1aNBAOXLkkKenp4KCgtS9e3fFxMQ4Vef169dVunRp2Ww27dq1y2Hat99+q9KlSytdunQKDg7WmDFjHmxjAMBtCN4AAAAAAA9lw4YNCg8P15YtW7Rq1SrduHFD9evX1+XLl+19OnbsqIMHD2rx4sXau3evWrZsqTZt2mjnzp2SpFOnTqlu3boqUKCAtm7dquXLl2v//v0KCwuzz8PNzU3PPPOMFi9erEOHDmn69OlavXq1XnnlFafq7Nevn3LkyJGofdmyZXr++ef1yiuvaN++fZo0aZI++eQTTZw48eE2DIAnHjdXcAI3VwAAAAAA5507d07+/v7asGGDqlevLkny8fHR5MmT1aFDB3u/LFmyaNSoUXrppZc0depUvfvuuzp9+rTc3G6dI7J3716VLFlShw8fVoECBZJc1vjx4zVmzBidPHnynjUtW7ZMvXv31oIFC1SsWDHt3LlTpUuXliS1b99eN27c0Pz58+39J0yYoNGjR+vEiROy2WzavXu3evbsqV9//VU2m00FCxbUZ599pvLlyz/MpgKQSnFzBQAAAABAioiOjpYkZc6c2d5WpUoVzZs3TxcuXFB8fLzmzp2ra9euqWbNmpJuXQbq4eFhD90kydvbW5L0008/JbmcU6dOaeHChapRo8Y96zlz5oy6du2qWbNmKV26dImmX79+XV5eXg5t3t7e+uuvv/Tnn39Kkp5//nnlypVL27dv144dOzRgwAClTZv2PlsCwJOO4A0AAAAAkGzi4+PVs2dPVa1aVcWLF7e3f/vtt7px44ayZMkiT09Pvfzyy1q0aJH9TLbatWsrMjJSY8aMUWxsrP79918NGDBAknT69GmHZbRr107p0qVTzpw55evrqy+++OKu9RhjFBYWpldeeeWuZ6eFhoZq4cKFWrNmjeLj43Xo0CF99NFHDss+ceKE6tatq8KFC6tgwYJ69tlnVapUqQffUACeCARvAAAAAIBkEx4ern379mnu3LkO7e+++66ioqK0evVq/frrr+rdu7fatGmjvXv3SpKKFSumGTNm6KOPPlK6dOkUGBiovHnzKiAgwOEsOEn65JNP9Ntvv+mHH37Q0aNH1bt377vWM2HCBF28eFEDBw68a5+uXbuqe/fuatKkiTw8PFS5cmW1bdtWkuzL7t27t1566SXVrVtXI0eO1NGjRx9o+wB4sjDGmxMY4w0AAAAA7q979+764YcftHHjRuXNm9fefvToURUoUED79u1TsWLF7O0JN1OYMmWKw3zOnDmj9OnTy2azydfXV3PnztWzzz6b5DJ/+uknVatWTadOnVL27NkTTW/evLn+97//yWaz2dvi4uLk7u6u559/XjNmzHBoj4yMVLZs2bRmzRo1atRIZ8+eVbZs2SRJhw4d0tKlS7Vs2TJt2LBBc+fOVYsWLR5sYwFI1ZzNitL8hzUBAAAAAB5Dxhi9/vrrWrRokdavX+8QuknSlStXJCnRmWvu7u6Kj49PNL+AgABJ0ldffSUvLy/Vq1fvrstOePz169eTnD5+/HgNHz7c/vupU6cUGhqqefPmqVKlSonqyZkzpyTpm2++UUhIiD10k6RChQqpUKFC6tWrl9q1a6dp06YRvAG4J4I3AAAAAMBDCQ8P15w5c/TDDz8oQ4YMioyMlCT5+fnJ29tbhQsXVoECBfTyyy/rww8/VJYsWfT9999r1apVWrJkiX0+EydOVJUqVeTj46NVq1apb9++GjlypDJmzChJ+vHHH3XmzBlVqFBBPj4+2r9/v/r27auqVasqT548kqRt27apY8eOWrNmjXLmzKncuXM71Orj4yNJyp8/v3LlyiVJ+ueff/Tdd9+pZs2aunbtmqZNm6b58+drw4YNkqSrV6+qb9++at26tfLmzau//vpL27dvV6tWrazcrAAeAwRvAAAAAICHMnnyZEmy36E0wbRp0xQWFqa0adPqxx9/1IABA9S0aVNdunRJBQoU0IwZM9SoUSN7/23btmnw4MG6dOmSChcurM8++0wdOnSwT/f29tbnn3+uXr166fr16woKClLLli3tN2GQbp1dd/DgQd24ccOldZgxY4b69OkjY4xCQkK0fv16VaxYUdKtM+HOnz+vjh076syZM8qaNatatmypoUOHurqpADxhGOPNCYzxBgAAAAAAgATOZkXc1RQAAAAAAACwAJeaAgAAAEkZ4pfSFQAA8PgYEp3SFaQIzngDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwQIoGbyNGjFCFChWUIUMG+fv7q3nz5jp48KBDn5o1a8pmszn8vPLKKw59Tpw4ocaNGytdunTy9/dX3759dfPmTYc+69evV9myZeXp6akCBQpo+vTpVq8eAAAAAAAAnmApGrxt2LBB4eHh2rJli1atWqUbN26ofv36unz5skO/rl276vTp0/af0aNH26fFxcWpcePGio2N1S+//KIZM2Zo+vTpGjRokL1PRESEGjdurFq1amnXrl3q2bOnXnrpJa1YseI/W1cAAAAAAAA8WWzGGJPSRSQ4d+6c/P39tWHDBlWvXl3SrTPeSpcurbFjxyb5mGXLlqlJkyY6deqUAgICJElTpkxR//79de7cOXl4eKh///5aunSp9u3bZ39c27ZtFRUVpeXLl9+3rpiYGPn5+Sk6Olq+vr4Pv6IAAAB49A3xS+kKAAB4fAyJTukKkpWzWdEjNcZbdPStJyFz5swO7bNnz1bWrFlVvHhxDRw4UFeuXLFP27x5s0qUKGEP3SQpNDRUMTEx2r9/v71P3bp1HeYZGhqqzZs3J1nH9evXFRMT4/ADAAAAAAAAuCJNSheQID4+Xj179lTVqlVVvHhxe3v79u0VHBysHDlyaM+ePerfv78OHjyohQsXSpIiIyMdQjdJ9t8jIyPv2ScmJkZXr16Vt7e3w7QRI0Zo6NChyb6OAAAAAAAAeHI8MsFbeHi49u3bp59++smhvVu3bvb/lyhRQtmzZ1edOnV09OhR5c+f35JaBg4cqN69e9t/j4mJUVBQkCXLAgAAAAAAwOPpkbjUtHv37lqyZInWrVunXLly3bNvpUqVJElHjhyRJAUGBurMmTMOfRJ+DwwMvGcfX1/fRGe7SZKnp6d8fX0dfgAAAAAAAABXpGjwZoxR9+7dtWjRIq1du1Z58+a972N27dolScqePbskKSQkRHv37tXZs2ftfVatWiVfX18VLVrU3mfNmjUO81m1apVCQkKSaU0AAAAAAAAARykavIWHh+vrr7/WnDlzlCFDBkVGRioyMlJXr16VJB09elTvvfeeduzYoePHj2vx4sXq2LGjqlevrpIlS0qS6tevr6JFi6pDhw7avXu3VqxYoXfeeUfh4eHy9PSUJL3yyis6duyY+vXrpz/++EOTJk3St99+q169eqXYugMAAAAAAODxZjPGmBRbuM2WZPu0adMUFhamkydP6oUXXtC+fft0+fJlBQUFqUWLFnrnnXccLv/8888/9eqrr2r9+vVKnz69OnXqpJEjRypNmv8bwm79+vXq1auXDhw4oFy5cundd99VWFiYU3U6e4tYAAAAPEaG+KV0BQAAPD6GRKd0BcnK2awoRYO31ILgDQAA4AlE8AYAQPJ5QoO3R+LmCgAAAAAAAMDjhuANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAOCEESNGqEKFCsqQIYP8/f3VvHlzHTx40KHP1KlTVbNmTfn6+spmsykqKirRfA4dOqRnnnlGWbNmla+vr55++mmtW7cuyWWeP39euXLluuu8knL9+nWVLl1aNptNu3btsrcfPHhQtWrVUkBAgLy8vJQvXz698847unHjhrObAAAAAADgIoI3AHDChg0bFB4eri1btmjVqlW6ceOG6tevr8uXL9v7XLlyRQ0aNNBbb7111/k0adJEN2/e1Nq1a7Vjxw6VKlVKTZo0UWRkZKK+Xbp0UcmSJV2qs1+/fsqRI0ei9rRp06pjx45auXKlDh48qLFjx+rzzz/X4MGDXZo/AAAAAMB5aVK6AABIDZYvX+7w+/Tp0+Xv768dO3aoevXqkqSePXtKktavX5/kPP755x8dPnxYX375pT1QGzlypCZNmqR9+/YpMDDQ3nfy5MmKiorSoEGDtGzZMqdqXLZsmVauXKkFCxYkeky+fPmUL18+++/BwcFav369Nm3aZG9bv369+vXrp/379ytt2rQqVqyY5syZo+DgYKeWDwAAAABwxBlvAPAAoqOjJUmZM2d2+jFZsmTRU089pZkzZ+ry5cu6efOmPvvsM/n7+6tcuXL2fgcOHNCwYcM0c+ZMubk5d5g+c+aMunbtqlmzZildunT37X/kyBEtX75cNWrUkCTdvHlTzZs3V40aNbRnzx5t3rxZ3bp1k81mc3r9AAAAAACOOOMNAFwUHx+vnj17qmrVqipevLjTj7PZbFq9erWaN2+uDBkyyM3NTf7+/lq+fLkyZcok6dYYbe3atdOYMWOUO3duHTt27L7zNcYoLCxMr7zyisqXL6/jx4/ftW+VKlX022+/6fr16+rWrZuGDRsmSYqJiVF0dLSaNGmi/PnzS5KKFCni9LoBAAAAABLjjDcAcFF4eLj27dunuXPnuvQ4Y4zCw8Pl7++vTZs2adu2bWrevLmaNm2q06dPS5IGDhyoIkWK6IUXXnB6vhMmTNDFixc1cODA+/adN2+efvvtN82ZM0dLly7Vhx9+KOnWmXthYWEKDQ1V06ZNNW7cOHtNAAAAAIAHQ/AGAC7o3r27lixZonXr1ilXrlwuPXbt2rVasmSJ5s6dq6pVq6ps2bKaNGmSvL29NWPGDHuf+fPnK02aNEqTJo3q1KkjScqaNetdb4Swdu1abd68WZ6enkqTJo0KFCggSSpfvrw6derk0DcoKEhFixZVu3btNHLkSA0ZMkRxcXGSpGnTpmnz5s2qUqWK5s2bp0KFCmnLli0urSMAAAAA4P9wqSkAOMEYo9dff12LFi3S+vXrlTdvXpfnceXKFUlKNG6bm5ub4uPjJUkLFizQ1atX7dO2b9+uF198UZs2bbJfAnqn8ePHa/jw4fbfT506pdDQUM2bN0+VKlW6az3x8fG6ceOG4uPj5e7uLkkqU6aMypQpo4EDByokJERz5sxR5cqVXV5XAAAAAADBGwA4JTw8XHPmzNEPP/ygDBkyKDIyUpLk5+cnb29vSVJkZKQiIyN15MgRSdLevXuVIUMG5c6dW5kzZ1ZISIgyZcqkTp06adCgQfL29tbnn3+uiIgINW7cWJIShWv//POPpFvjrWXMmFGStG3bNnXs2FFr1qxRzpw5lTt3bofH+Pj42OeVcFbe7NmzlTZtWpUoUUKenp769ddfNXDgQD333HNKmzatIiIiNHXqVDVr1kw5cuTQwYMHdfjwYXXs2NGCrQkAAAAATwaCNwBwwuTJkyVJNWvWdGifNm2awsLCJElTpkzR0KFD7dOqV6/u0Cdr1qxavny53n77bdWuXVs3btxQsWLF9MMPP6hUqVJO13LlyhUdPHhQN27ccPoxadKk0ahRo3To0CEZYxQcHKzu3burV69ekqR06dLpjz/+0IwZM3T+/Hllz55d4eHhevnll51eBgAAAADAkc0YY1K6iEddTEyM/Pz8FB0dLV9f35QuBwAAAP+FIX4pXQEAAI+PIdEpXUGycjYr4uYKAAAAAAAAgAUI3gAAAAAAAAALMMbbEyzPgKUpXQIAAI+N4yMbp3QJAAAAeMRwxhsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALBAigZvI0aMUIUKFZQhQwb5+/urefPmOnjwoEOfa9euKTw8XFmyZJGPj49atWqlM2fOOPQ5ceKEGjdurHTp0snf3199+/bVzZs3HfqsX79eZcuWlaenpwoUKKDp06dbvXoAAAAAAAB4gqVo8LZhwwaFh4dry5YtWrVqlW7cuKH69evr8uXL9j69evXS//73P82fP18bNmzQqVOn1LJlS/v0uLg4NW7cWLGxsfrll180Y8YMTZ8+XYMGDbL3iYiIUOPGjVWrVi3t2rVLPXv21EsvvaQVK1b8p+sLAAAAAACAJ4fNGGNSuogE586dk7+/vzZs2KDq1asrOjpa2bJl05w5c9S6dWtJ0h9//KEiRYpo8+bNqly5spYtW6YmTZro1KlTCggIkCRNmTJF/fv317lz5+Th4aH+/ftr6dKl2rdvn31Zbdu2VVRUlJYvX37fumJiYuTn56fo6Gj5+vpas/IpIM+ApSldAgAAj43jIxundAlIbkP8UroCAAAeH0OiU7qCZOVsVvRIjfEWHX3rScicObMkaceOHbpx44bq1q1r71O4cGHlzp1bmzdvliRt3rxZJUqUsIdukhQaGqqYmBjt37/f3uf2eST0SZjHna5fv66YmBiHHwAAAAAAAMAVj0zwFh8fr549e6pq1aoqXry4JCkyMlIeHh7KmDGjQ9+AgABFRkba+9weuiVMT5h2rz4xMTG6evVqolpGjBghPz8/+09QUFCyrCMAAAAAAACeHI9M8BYeHq59+/Zp7ty5KV2KBg4cqOjoaPvPyZMnU7okAAAAAAAApDJpHuRBJ06c0J9//qkrV64oW7ZsKlasmDw9PR+4iO7du2vJkiXauHGjcuXKZW8PDAxUbGysoqKiHM56O3PmjAIDA+19tm3b5jC/hLue3t7nzjuhnjlzRr6+vvL29k5Uj6en50OtDwAAAAAAAOD0GW/Hjx9X//79FRwcrLx586pGjRpq2LChypcvLz8/P9WrV0/z589XfHy80ws3xqh79+5atGiR1q5dq7x58zpML1eunNKmTas1a9bY2w4ePKgTJ04oJCREkhQSEqK9e/fq7Nmz9j6rVq2Sr6+vihYtau9z+zwS+iTMAwAAAAAAAEhuTgVvPXr0UKlSpRQREaHhw4frwIEDio6OVmxsrCIjI/Xjjz/q6aef1qBBg1SyZElt377dqYWHh4fr66+/1pw5c5QhQwZFRkYqMjLSPu6an5+funTpot69e2vdunXasWOHOnfurJCQEFWuXFmSVL9+fRUtWlQdOnTQ7t27tWLFCr3zzjsKDw+3n7X2yiuv6NixY+rXr5/++OMPTZo0Sd9++6169er1INsMAAAAAAAAuC+nLjVNnz69jh07pixZsiSa5u/vr9q1a6t27doaPHiwli9frpMnT6pChQr3ne/kyZMlSTVr1nRonzZtmsLCwiRJn3zyidzc3NSqVStdv35doaGhmjRpkr2vu7u7lixZoldffVUhISFKnz69OnXqpGHDhtn75M2bV0uXLlWvXr00btw45cqVS1988YVCQ0OdWX0AAAAAAADAZTZjjEnpIh51MTEx8vPzU3R0tHx9fVO6nGSTZ8DSlC4BAIDHxvGRjVO6BCS3IX4pXQEAAI+PIdEpXUGycjYrcvmuphERETp8+HCi9sOHD+v48eOuzg4AAAAAAAB4LLkcvIWFhemXX35J1L5161b75aEAAAAAAADAk87l4G3nzp2qWrVqovbKlStr165dyVETAAAAAAAAkOq5HLzZbDZdvHgxUXt0dLTi4uKSpSgAAAAAAAAgtXM5eKtevbpGjBjhELLFxcVpxIgRevrpp5O1OAAAAAAAACC1SuPqA0aNGqXq1avrqaeeUrVq1SRJmzZtUkxMjNauXZvsBQIAAAAAAACpkctnvBUtWlR79uxRmzZtdPbsWV28eFEdO3bUH3/8oeLFi1tRIwAAAAAAAJDquHzGmyTlyJFDH3zwQXLXAgAAAAAAADw2XD7jTbp1aekLL7ygKlWq6O+//5YkzZo1Sz/99FOyFgcAAAAAAACkVi4HbwsWLFBoaKi8vb3122+/6fr165Ju3dWUs+AAAAAAAACAW1wO3oYPH64pU6bo888/V9q0ae3tVatW1W+//ZasxQEAAAAAAACplcvB28GDB1W9evVE7X5+foqKikqOmgAAAAAAAIBUz+XgLTAwUEeOHEnU/tNPPylfvnzJUhQAAAAAAACQ2rkcvHXt2lVvvPGGtm7dKpvNplOnTmn27Nnq06ePXn31VStqBAAAAAAAAFKdNK4+YMCAAYqPj1edOnV05coVVa9eXZ6enurTp49ef/11K2oEAAAAAAAAUh2Xgzebzaa3335bffv21ZEjR3Tp0iUVLVpUPj4+VtQHAAAAAAAApEouX2qawMPDQ0WLFlXhwoW1evVq/f7778lZFwAAAAAAAJCquRy8tWnTRhMnTpQkXb16VRUqVFCbNm1UsmRJLViwINkLBAAAAAAAAFIjl4O3jRs3qlq1apKkRYsWKT4+XlFRURo/fryGDx+e7AUCAAAAAAAAqZHLwVt0dLQyZ84sSVq+fLlatWqldOnSqXHjxjp8+HCyFwgAAAAAAACkRi4Hb0FBQdq8ebMuX76s5cuXq379+pKkf//9V15eXsleIAAAAAAAAJAauXxX0549e+r555+Xj4+PgoODVbNmTUm3LkEtUaJEctcHAAAAAAAApEouB2+vvfaaKlWqpBMnTqhevXpyc7t10ly+fPkY4w0AAAAAAAD4/1wO3iSpXLlyKleunENb48aNk6UgAAAAAAAA4HHg1BhvI0eO1NWrV52a4datW7V06dKHKgoAAAAAAABI7ZwK3g4cOKDcuXPrtdde07Jly3Tu3Dn7tJs3b2rPnj2aNGmSqlSpoueee04ZMmSwrGAAAAAAAAAgNXDqUtOZM2dq9+7dmjhxotq3b6+YmBi5u7vL09NTV65ckSSVKVNGL730ksLCwri7KQAAAAAAAJ54To/xVqpUKX3++ef67LPPtGfPHv3555+6evWqsmbNqtKlSytr1qxW1gkAAAAAAACkKi7fXMHNzU2lS5dW6dKlLSgHAAAAAAAAeDw4NcYbAAAAAAAAANcQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFjgoYO3mJgYff/99/r999+Tox4AAAAAAADgseBy8NamTRtNnDhRknT16lWVL19ebdq0UcmSJbVgwYJkLxAAAAAAAABIjVwO3jZu3Khq1apJkhYtWiRjjKKiojR+/HgNHz482QsEAAAAAAAAUiOXg7fo6GhlzpxZkrR8+XK1atVK6dKlU+PGjXX48OFkLxAAAAAAAABIjVwO3oKCgrR582ZdvnxZy5cvV/369SVJ//77r7y8vJK9QAAAAAAAACA1SuPqA3r27Knnn39ePj4+Cg4OVs2aNSXdugS1RIkSyV0fAAAAAAAAkCq5HLy99tprqlixok6ePKl69erJze3WSXP58uVjjDcAAAAAAADg/3M5eJOk8uXLq3z58pKkuLg47d27V1WqVFGmTJmStTgAAAAAAAAgtXJ5jLeePXvqyy+/lHQrdKtRo4bKli2roKAgrV+/PrnrAwAAAAAAAFIll4O37777TqVKlZIk/e9//1NERIT++OMP9erVS2+//XayFwgAAAAAAACkRi4Hb//8848CAwMlST/++KOeffZZFSpUSC+++KL27t2b7AUCAAAAAAAAqZHLwVtAQIAOHDiguLg4LV++XPXq1ZMkXblyRe7u7sleIAAAAAAAAJAauXxzhc6dO6tNmzbKnj27bDab6tatK0naunWrChcunOwFAgAAAAAAAKmRy8HbkCFDVLx4cZ08eVLPPvusPD09JUnu7u4aMGBAshcIAAAAAAAApEYuB2+S1Lp160RtnTp1euhiAAAAAAAAgMeFy2O8SdKGDRvUtGlTFShQQAUKFFCzZs20adOm5K4NAAAAAAAASLVcDt6+/vpr1a1bV+nSpVOPHj3Uo0cPeXt7q06dOpozZ44VNQIAAAAAAACpjsuXmr7//vsaPXq0evXqZW/r0aOHPv74Y7333ntq3759shYIAAAAAAAApEYun/F27NgxNW3aNFF7s2bNFBERkSxFAQAAAAAAAKmdy8FbUFCQ1qxZk6h99erVCgoKSpaiAAAAAAAAgNTO5UtN33zzTfXo0UO7du1SlSpVJEk///yzpk+frnHjxiV7gQAAAAAAAEBq5HLw9uqrryowMFAfffSRvv32W0lSkSJFNG/ePD3zzDPJXiAAAAAAAACQGrkcvElSixYt1KJFi+SuBQAAAAAAAHhsuDzGGwAAAAAAAID7c+qMt0yZMslmszk1wwsXLjxUQQAAAAAAAMDjwKngbezYsRaXAQAAAAAAADxenAreOnXqZHUdAAAAAAAAwGOFMd4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALCAU3c1bdmypdMzXLhw4QMXAwAAAAAAADwunAre/Pz8rK4DAAAAAAAAeKw4FbxNmzbN6joAAAAAAACAxwpjvAEAAAAAAAAWcOqMtzt99913+vbbb3XixAnFxsY6TPvtt9+SpTAAAAAAAAAgNXP5jLfx48erc+fOCggI0M6dO1WxYkVlyZJFx44dU8OGDa2oEQAAAAAAAEh1XA7eJk2apKlTp2rChAny8PBQv379tGrVKvXo0UPR0dFW1AgAAAAAAACkOi4HbydOnFCVKlUkSd7e3rp48aIkqUOHDvrmm2+StzoAAAAAAAAglXI5eAsMDNSFCxckSblz59aWLVskSRERETLGJG91AAAAAAAAQCrlcvBWu3ZtLV68WJLUuXNn9erVS/Xq1dNzzz2nFi1aJHuBAAAAAAAAQGrk8l1Np06dqvj4eElSeHi4smTJol9++UXNmjXTyy+/nOwFAgAAAAAAAKmRy8Gbm5ub3Nz+70S5tm3bqm3btslaFAAAAAAAAJDauXypaYECBTRkyBAdOnTIinoAAAAAAACAx4LLwVt4eLiWLl2qIkWKqEKFCho3bpwiIyOtqA0AAAAAAABItVwO3nr16qXt27fr999/V6NGjfTpp58qKChI9evX18yZM62oEQAAAAAAAEh1XA7eEhQqVEhDhw7VoUOHtGnTJp07d06dO3dOztoAAAAAAACAVMvlmyvcbtu2bZozZ47mzZunmJgYPfvss8lVFwAAAAAAAJCquRy8HTp0SLNnz9Y333yjiIgI1a5dW6NGjVLLli3l4+NjRY0AAAAAAABAquNy8Fa4cGFVqFBB4eHhatu2rQICAqyoCwAAAAAAAEjVXA7eDh48qIIFC1pRCwAAAAAAAPDYcPnmCoRuAAAAAAAAwP098F1NAQAAAAAAANwdwRsAAAAAAABgAYI3AAAAAAAAwAIuB2/Dhg3TlStXErVfvXpVw4YNS5aiAAAAAAAAgNTO5eBt6NChunTpUqL2K1euaOjQoclSFAAAAAAAAJDauRy8GWNks9kSte/evVuZM2d2aV4bN25U06ZNlSNHDtlsNn3//fcO08PCwmSz2Rx+GjRo4NDnwoULev755+Xr66uMGTOqS5cuiYLBPXv2qFq1avLy8lJQUJBGjx7tUp0AAAAAAACAq9I42zFTpkz28KtQoUIO4VtcXJwuXbqkV155xaWFX758WaVKldKLL76oli1bJtmnQYMGmjZtmv13T09Ph+nPP/+8Tp8+rVWrVunGjRvq3LmzunXrpjlz5kiSYmJiVL9+fdWtW1dTpkzR3r179eKLLypjxozq1q2bS/UCAAAAAAAAznI6eBs7dqyMMXrxxRc1dOhQ+fn52ad5eHgoT548CgkJcWnhDRs2VMOGDe/Zx9PTU4GBgUlO+/3337V8+XJt375d5cuXlyRNmDBBjRo10ocffqgcOXJo9uzZio2N1VdffSUPDw8VK1ZMu3bt0scff3zX4O369eu6fv26/feYmBiX1gsAAAAAAABwOnjr1KmTJClv3ryqWrWq0qRx+qEPZf369fL391emTJlUu3ZtDR8+XFmyZJEkbd68WRkzZrSHbpJUt25dubm5aevWrWrRooU2b96s6tWry8PDw94nNDRUo0aN0r///qtMmTIlWuaIESMYrw4AAAAAAAAPxeUx3jJkyKDff//d/vsPP/yg5s2b66233lJsbGyyFtegQQPNnDlTa9as0ahRo7RhwwY1bNhQcXFxkqTIyEj5+/s7PCZNmjTKnDmzIiMj7X0CAgIc+iT8ntDnTgMHDlR0dLT95+TJk8m6XgAAAAAAAHj8uRy8vfzyyzp06JAk6dixY3ruueeULl06zZ8/X/369UvW4tq2batmzZqpRIkSat68uZYsWaLt27dr/fr1ybqcO3l6esrX19fhBwAAAAAAAHCFy8HboUOHVLp0aUnS/PnzVaNGDc2ZM0fTp0/XggULkrs+B/ny5VPWrFl15MgRSVJgYKDOnj3r0OfmzZu6cOGCfVy4wMBAnTlzxqFPwu93GzsOAAAAAAAAeFguB2/GGMXHx0uSVq9erUaNGkmSgoKC9M8//yRvdXf466+/dP78eWXPnl2SFBISoqioKO3YscPeZ+3atYqPj1elSpXsfTZu3KgbN27Y+6xatUpPPfVUkuO7AQAAAAAAAMnB5eCtfPnyGj58uGbNmqUNGzaocePGkqSIiIhEY6ndz6VLl7Rr1y7t2rXLPo9du3bpxIkTunTpkvr27astW7bo+PHjWrNmjZ555hkVKFBAoaGhkqQiRYqoQYMG6tq1q7Zt26aff/5Z3bt3V9u2bZUjRw5JUvv27eXh4aEuXbpo//79mjdvnsaNG6fevXu7uuoAAAAAAACA01wO3saOHavffvtN3bt319tvv60CBQpIkr777jtVqVLFpXn9+uuvKlOmjMqUKSNJ6t27t8qUKaNBgwbJ3d1de/bsUbNmzVSoUCF16dJF5cqV06ZNm+Tp6Wmfx+zZs1W4cGHVqVNHjRo10tNPP62pU6fap/v5+WnlypWKiIhQuXLl9Oabb2rQoEHq1q2bq6sOAAAAAAAAOM1mjDHJMaNr167J3d1dadOmTY7ZPVJiYmLk5+en6Ojox+pGC3kGLE3pEgAAeGwcH9k4pUtAchvil9IVAADw+BgSndIVJCtnsyKXz3iTpKioKH3xxRcaOHCgLly4IEk6cOBAohsdAAAAAAAAAE+qNK4+YM+ePapTp44yZsyo48ePq2vXrsqcObMWLlyoEydOaObMmVbUCQAAAAAAAKQqLp/x1rt3b3Xu3FmHDx+Wl5eXvb1Ro0bauHFjshYHAAAAAAAApFYuB2/bt2/Xyy+/nKg9Z86cioyMTJaiAAAAAAAAgNTO5eDN09NTMTExidoPHTqkbNmyJUtRAAAAAAAAQGrncvDWrFkzDRs2TDdu3JAk2Ww2nThxQv3791erVq2SvUAAAAAAAAAgNXI5ePvoo4906dIl+fv76+rVq6pRo4YKFCigDBky6P3337eiRgAAAAAAACDVcfmupn5+flq1apV++ukn7dmzR5cuXVLZsmVVt25dK+oDAAAAAAAAUiWXg7cETz/9tJ5++unkrAUAAAAAAAB4bLh8qakkrVmzRk2aNFH+/PmVP39+NWnSRKtXr07u2gAAAAAAAIBUy+XgbdKkSWrQoIEyZMigN954Q2+88YZ8fX3VqFEjffrpp1bUCAAAAAAAAKQ6Ll9q+sEHH+iTTz5R9+7d7W09evRQ1apV9cEHHyg8PDxZCwQAAAAAAABSI5fPeIuKilKDBg0StdevX1/R0dHJUhQAAAAAAACQ2rkcvDVr1kyLFi1K1P7DDz+oSZMmyVIUAAAAAAAAkNo5danp+PHj7f8vWrSo3n//fa1fv14hISGSpC1btujnn3/Wm2++aU2VAAAAAAAAQCpjM8aY+3XKmzevczOz2XTs2LGHLupRExMTIz8/P0VHR8vX1zely0k2eQYsTekSAAB4bBwf2TilS0ByG+KX0hUAAPD4GPJ4DU/mbFbk1BlvERERyVYYAAAAAAAA8CRweYw3AAAAAAAAAPdH8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAk7d1XTPnj1Oz7BkyZIPXAwAAAAAAADwuHAqeCtdurRsNpuMMUlOT5hms9kUFxeXrAUCAAAAAAAAqZFTwVtERITVdQAAAAAAAACPFaeCt+DgYKvrAAAAAAAAAB4rTgVvixcvVsOGDZU2bVotXrz4nn2bNWuWLIUBAAAAAAAAqZlTwVvz5s0VGRkpf39/NW/e/K79GOMNAAAAAAAAuMWp4C0+Pj7J/wMAAAAAAABImpurD5g5c6auX7+eqD02NlYzZ85MlqIAAAAAAACA1M7l4K1z586Kjo5O1H7x4kV17tw5WYoCAAAAAAAAUjuXgzdjjGw2W6L2v/76S35+fslSFAAAAAAAAJDaOTXGmySVKVNGNptNNptNderUUZo0//fQuLg4RUREqEGDBpYUCQAAAAAAAKQ2TgdvCXcz3bVrl0JDQ+Xj42Of5uHhoTx58qhVq1bJXiAAAAAAAACQGjkdvA0ePFiSlCdPHj333HPy8vKyrCgAAAAAAAAgtXM6eEvQqVMnSbfuYnr27FnFx8c7TM+dO3fyVAYAAAAAAACkYi4Hb4cPH9aLL76oX375xaE94aYLcXFxyVYcAAAAAAAAkFq5HLyFhYUpTZo0WrJkibJnz57kHU4BAAAAAACAJ53LwduuXbu0Y8cOFS5c2Ip6AAAAAAAAgMeCm6sPKFq0qP755x8ragEAAAAAAAAeGy4Hb6NGjVK/fv20fv16nT9/XjExMQ4/AAAAAAAAAB7gUtO6detKkurUqePQzs0VAAAAAAAAgP/jcvC2bt06K+oAAAAAAAAAHisuB281atSwog4AAAAAAADgseJy8LZx48Z7Tq9evfoDFwMAAAAAAAA8LlwO3mrWrJmozWaz2f/PGG8AAAAAAADAA9zV9N9//3X4OXv2rJYvX64KFSpo5cqVVtQIAAAAAAAApDoun/Hm5+eXqK1evXry8PBQ7969tWPHjmQpDAAAAAAAAEjNXD7j7W4CAgJ08ODB5JodAAAAAAAAkKq5fMbbnj17HH43xuj06dMaOXKkSpcunVx1AQAAAAAAAKmay8Fb6dKlZbPZZIxxaK9cubK++uqrZCsMAAAAAAAASM1cDt4iIiIcfndzc1O2bNnk5eWVbEUBAAAAAAAAqZ3LwVtwcLAVdQAAAAAAAACPlWS7uQIAAAAAAACA/0PwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYIEHCt6OHj2qd955R+3atdPZs2clScuWLdP+/fuTtTgAAAAAAAAgtXI5eNuwYYNKlCihrVu3auHChbp06ZIkaffu3Ro8eHCyFwgAAAAAAACkRi4HbwMGDNDw4cO1atUqeXh42Ntr166tLVu2JGtxAAAAAAAAQGrlcvC2d+9etWjRIlG7v7+//vnnn2QpCgAAAAAAAEjtXA7eMmbMqNOnTydq37lzp3LmzJksRQEAAAAAAACpncvBW9u2bdW/f39FRkbKZrMpPj5eP//8s/r06aOOHTtaUSMAAAAAAACQ6rgcvH3wwQcqXLiwgoKCdOnSJRUtWlTVq1dXlSpV9M4771hRIwAAAAAAAJDqpHH1AR4eHvr888/17rvvat++fbp06ZLKlCmjggULWlEfAAAAAAAAkCq5HLwlyJ07t3Lnzp2ctQAAAAAAAACPDZeDN2OMvvvuO61bt05nz55VfHy8w/SFCxcmW3EAAAAAAABAauVy8NazZ0999tlnqlWrlgICAmSz2ayoCwAAAAAAAEjVXA7eZs2apYULF6pRo0ZW1AMAAAAAAAA8Fly+q6mfn5/y5ctnRS0AAAAAAADAY8Pl4G3IkCEaOnSorl69akU9AAAAAAAAwGPB5UtN27Rpo2+++Ub+/v7KkyeP0qZN6zD9t99+S7biAAAAAAAAgNTK5eCtU6dO2rFjh1544QVurgAAAAAAAADchcvB29KlS7VixQo9/fTTVtQDAAAAAAAAPBZcHuMtKChIvr6+VtQCAAAAAAAAPDZcDt4++ugj9evXT8ePH7egHAAAAAAAAODx4PKlpi+88IKuXLmi/PnzK126dIlurnDhwoVkKw4AAAAAAABIrVwO3saOHWtBGQAAAAAAAMDj5YHuagoAAAAAAADg3pwK3mJiYuw3VIiJiblnX268AAAAAAAAADgZvGXKlEmnT5+Wv7+/MmbMKJvNlqiPMUY2m01xcXHJXiQAAAAAAACQ2jgVvK1du1aZM2eWJK1bt87SggAAAAAAAIDHgVPBW40aNez/z5s3r4KCghKd9WaM0cmTJ5O3OgAAAAAAACCVcnP1AXnz5tW5c+cStV+4cEF58+ZNlqIAAAAAAACA1M7l4C1hLLc7Xbp0SV5eXslSFAAAAAAAAJDaOXWpqST17t1bkmSz2fTuu+8qXbp09mlxcXHaunWrSpcunewFAgAAAAAAAKmR08Hbzp07Jd06423v3r3y8PCwT/Pw8FCpUqXUp0+f5K8QAAAAAAAASIWcDt4S7mbauXNnjRs3Tr6+vpYVBQAAAAAAAKR2TgdvCaZNm2ZFHQAAAAAAAMBjxeWbKwAAAAAAAAC4vxQN3jZu3KimTZsqR44cstls+v777x2mG2M0aNAgZc+eXd7e3qpbt64OHz7s0OfChQt6/vnn5evrq4wZM6pLly66dOmSQ589e/aoWrVq8vLyUlBQkEaPHm31qgEAAAAAAOAJl6LB2+XLl1WqVCl9+umnSU4fPXq0xo8frylTpmjr1q1Knz69QkNDde3aNXuf559/Xvv379eqVau0ZMkSbdy4Ud26dbNPj4mJUf369RUcHKwdO3ZozJgxGjJkiKZOnWr5+gEAAAAAAODJ5fIYb8mpYcOGatiwYZLTjDEaO3as3nnnHT3zzDOSpJkzZyogIEDff/+92rZtq99//13Lly/X9u3bVb58eUnShAkT1KhRI3344YfKkSOHZs+erdjYWH311Vfy8PBQsWLFtGvXLn388ccOAR0AAAAAAACQnB7ZMd4iIiIUGRmpunXr2tv8/PxUqVIlbd68WZK0efNmZcyY0R66SVLdunXl5uamrVu32vtUr15dHh4e9j6hoaE6ePCg/v333ySXff36dcXExDj8AAAAAAAAAK54ZIO3yMhISVJAQIBDe0BAgH1aZGSk/P39HaanSZNGmTNnduiT1DxuX8adRowYIT8/P/tPUFDQw68QAAAAAAAAniiPbPCWkgYOHKjo6Gj7z8mTJ1O6JAAAAAAAAKQyj2zwFhgYKEk6c+aMQ/uZM2fs0wIDA3X27FmH6Tdv3tSFCxcc+iQ1j9uXcSdPT0/5+vo6/AAAAAAAAACueGSDt7x58yowMFBr1qyxt8XExGjr1q0KCQmRJIWEhCgqKko7duyw91m7dq3i4+NVqVIle5+NGzfqxo0b9j6rVq3SU089pUyZMv1HawMAAAAAAIAnTYoGb5cuXdKuXbu0a9cuSbduqLBr1y6dOHFCNptNPXv21PDhw7V48WLt3btXHTt2VI4cOdS8eXNJUpEiRdSgQQN17dpV27Zt088//6zu3burbdu2ypEjhySpffv28vDwUJcuXbR//37NmzdP48aNU+/evVNorQEAAAAAAPAkSJOSC//1119Vq1Yt++8JYVinTp00ffp09evXT5cvX1a3bt0UFRWlp59+WsuXL5eXl5f9MbNnz1b37t1Vp04dubm5qVWrVho/frx9up+fn1auXKnw8HCVK1dOWbNm1aBBg9StW7f/bkUBAAAAAADwxLEZY0xKF/Goi4mJkZ+fn6Kjox+r8d7yDFia0iUAAPDYOD6ycUqXgOQ2xC+lKwAA4PExJDqlK0hWzmZFj+wYbwAAAAAAAEBqRvAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWOCRDt6GDBkim83m8FO4cGH79GvXrik8PFxZsmSRj4+PWrVqpTNnzjjM48SJE2rcuLHSpUsnf39/9e3bVzdv3vyvVwUAAAAAAABPmDQpXcD9FCtWTKtXr7b/nibN/5Xcq1cvLV26VPPnz5efn5+6d++uli1b6ueff5YkxcXFqXHjxgoMDNQvv/yi06dPq2PHjkqbNq0++OCD/3xdAAAAAAAA8OR45IO3NGnSKDAwMFF7dHS0vvzyS82ZM0e1a9eWJE2bNk1FihTRli1bVLlyZa1cuVIHDhzQ6tWrFRAQoNKlS+u9995T//79NWTIEHl4ePzXqwMAAAAAAIAnxCN9qakkHT58WDly5FC+fPn0/PPP68SJE5KkHTt26MaNG6pbt669b+HChZU7d25t3rxZkrR582aVKFFCAQEB9j6hoaGKiYnR/v3777rM69evKyYmxuEHAAAAAAAAcMUjHbxVqlRJ06dP1/LlyzV58mRFRESoWrVqunjxoiIjI+Xh4aGMGTM6PCYgIECRkZGSpMjISIfQLWF6wrS7GTFihPz8/Ow/QUFBybtiAAAAAAAAeOw90peaNmzY0P7/kiVLqlKlSgoODta3334rb29vy5Y7cOBA9e7d2/57TEwM4RsAAAAAAABc8kif8XanjBkzqlChQjpy5IgCAwMVGxurqKgohz5nzpyxjwkXGBiY6C6nCb8nNW5cAk9PT/n6+jr8AAAAAAAAAK5IVcHbpUuXdPToUWXPnl3lypVT2rRptWbNGvv0gwcP6sSJEwoJCZEkhYSEaO/evTp79qy9z6pVq+Tr66uiRYv+5/UDAAAAAADgyfFIX2rap08fNW3aVMHBwTp16pQGDx4sd3d3tWvXTn5+furSpYt69+6tzJkzy9fXV6+//rpCQkJUuXJlSVL9+vVVtGhRdejQQaNHj1ZkZKTeeecdhYeHy9PTM4XXDgAAAAAAAI+zRzp4++uvv9SuXTudP39e2bJl09NPP60tW7YoW7ZskqRPPvlEbm5uatWqla5fv67Q0FBNmjTJ/nh3d3ctWbJEr776qkJCQpQ+fXp16tRJw4YNS6lVAgAAAAAAwBPCZowxKV3Eoy4mJkZ+fn6Kjo5+rMZ7yzNgaUqXAADAY+P4yMYpXQKS2xC/lK4AAIDHx5DolK4gWTmbFaWqMd4AAAAAAACA1ILgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEb/h/7d15nM71/v/xx8ww9mXsRAcNSagpSYs1JaFoIkQoytpGdbKljqKctFCic4qKKJJkDxNqrFlCJBKKIfs+Zq7r94ffdZ0jOt+zdDWGx/12c2vmc31Wt1vjNc/P+/1+SZIkSZIkKQIM3iRJkiRJkqQIMHiTJEmSJEmSIsDgTZIkSZIkSYoAgzdJkiRJkiQpAgzeJEmSJEmSpAgweJMkSZIkSZIiwOBNkiRJkiRJigCDN0mSJEmSJCkCDN4kSZIkSZKkCDB4kyRJkiRJkiLA4E2SJEmSJEmKAIM3SZIkSZIkKQIM3iRJkiRJkqQIMHiTJEmSJEmSIsDgTZIkSZIkSYoAgzdJkiRJkiQpAgzeJEmSJEmSpAgweJMkSZIkSZIiwOBNkiRJkiRJigCDN0mSJEmSJCkCDN4kSZIkSZKkCDB4kyRJkiRJkiLA4E2SJEmSJEmKAIM3SZIkSZIkKQIM3iRJkiRJkqQIMHiTJEmSJEmSIsDgTZIkSZIkSYoAgzdJkiRJkiQpAgzeJEmSJEmSpAgweJMkSZIkSZIiwOBNkiRJkiRJigCDN0mSJEmSJCkCDN4kSZIkSZKkCDB4kyRJkiRJkiLA4E2SJEmSJEmKAIM3SZIkSZIkKQIM3iRJkiRJkqQIMHiTJEmSJEmSIsDgTZIkSZIkSYoAgzdJkiRJkiQpAgzeJEmSJEmSpAgweJMkSZIkSZIiwOBNkiRJkiRJigCDN0mSJEmSJCkCDN4kSZIkSZKkCDB4kyRJkiRJkiLA4E2SJEmSJEmKAIM3SZIkSZIkKQIM3iRJkiRJkqQIMHiTJEmSJEmSIsDgTZIkSZIkSYoAgzdJkiRJkiQpAgzeJEmSJEmSpAgweJMkSZIkSZIiwOBNkiRJkiRJigCDN0mSJEmSJCkCDN4kSZIkSZKkCDB4kyRJkiRJkiLA4E2SJEmSJEmKAIM3SZIkSZIkKQIM3iRJkiRJkqQIMHiTJEmSJEmSIsDgTZIkSZIkSYoAgzdJkiRJkiQpAgzeJEmSJEmSpAgweJMkSZIkSZIiwOBNkiRJkiRJigCDN0mSJEmSJCkCDN4kSZIkSZKkCDB4kyRJkiRJkiLA4E2SJEmSJEmKAIM3SZIkSZIkKQIM3iRJkiRJkqQIMHiTJEmSJEmSIsDgTZIkSZIkSYoAgzdJkiRJkiQpAgzeJEmSJEmSpAgweJMkSZIkSZIi4IIK3l5//XVKly5N9uzZufbaa1myZElG35IkSZIkSZLOUxdM8DZ+/Hgee+wxnn76ab7++muuuOIK6tevz65duzL61iRJkiRJknQeumCCtyFDhtCxY0fat29PxYoVefPNN8mZMydvv/12Rt+aJEmSJEmSzkNZMvoG/gipqaksX76cp556KrwtOjqaevXqkZycfMb+J06c4MSJE+HvDxw4AMDBgwcjf7N/oMCJoxl9C5IknTfOtzpBwIlgRt+BJEnnj/OsVgrVfsHgv64XLojg7ZdffiE9PZ2iRYuetr1o0aKsX7/+jP0HDhzIM888c8b2UqVKReweJUlS5pbvlYy+A0mSpHPYoHwZfQcRcejQIfLl++1nuyCCt//UU089xWOPPRb+PhAIsHfvXgoWLEhUVFQG3pmkC83BgwcpVaoU27ZtI2/evBl9O5IkSecUayVJGSUYDHLo0CFKlCjxL/e7IIK3QoUKERMTQ0pKymnbU1JSKFas2Bn7Z8uWjWzZsp22LX/+/JG8RUn6l/LmzWsxKUmS9BuslSRlhH810i3kgmiuEBsby9VXX82cOXPC2wKBAHPmzOG6667LwDuTJEmSJEnS+eqCGPEG8Nhjj9G2bVuqVq1KtWrVeOWVVzhy5Ajt27fP6FuTJEmSJEnSeeiCCd7uvvtudu/eTb9+/di5cydXXnklM2bMOKPhgiSdS7Jly8bTTz99xvR3SZIkWStJOvdFBf+vvqeSJEmSJEmS/mMXxBpvkiRJkiRJ0h/N4E2SJEmSJEmKAIM3SZIkSZIkKQIM3iRJkiRJkqQIMHiTpAw0YcIE7r33XgACgUAG340kSZIk6fdk8CZJGejkyZO8//77bNy4kehofyRLkiRJ0vkkKhgMBjP6JiTpQrVv3z5uvfVWKlSowOjRowkGg0RFRWX0bUmSJGW49PR0oqKifDkpKVPzJ5gk/YFC00lD7zzi4uLo0qULH3zwASkpKYZukiRJ/19MTAzR0dFs2bKF3bt345gRSZmRwZsk/QHS09MBwm9s/zlgq1+/PmXKlGHQoEEAFpWSJOmClJaWdtr3W7Zs4eabb+byyy/njjvuYODAgYC1kqTMxeBNkv4AMTExAEybNo2uXbvyzjvvsHbtWgAKFixIly5deOuttzhy5Iij3iRJ0gUlFKRlyZIFgO+//x6Ar7/+msqVK7NgwQJq1qxJnz59WLZsmbWSpEzFNd4k6Q+wZMkSunfvzvbt26lVqxYbNmxgz549rFq1inz58rF161auu+46OnfuTJ8+fVzrTZIkXXA+++wzOnfuTHR0NOXKlSMtLY1XX32VK664Ajg1SyAmJoYpU6aEX2pK0rnO4E2SfifBYJBAIHBGIXj8+HFefvlljhw5wlNPPUWuXLk4cuQIF198Me3ateOll14iGAzy7LPPMmzYMFJSUlxEWJIknbcCgQDR0dHh/44aNYrU1FQWLFjAjTfeSMGCBRk4cCB79uzh888/Jz4+HoB58+ZRr149kpOTqVatWgY/hST9e/zNTpL+R8FgMDxCLSYmhmPHjrFkyZLwtIns2bNz/fXX07NnT3LkyMHgwYOpWLEiUVFRvPXWW3z77bdERUXRqlUrAEaOHBk+ryRJ0vkmOjqa48ePc+LECQAmTpxIp06dCAQCPPjgg9x111288847bN26lW+//TZcE9WpU4drrrmGoUOHZuTtS9J/xOBNkv5HUVFRREVFceLECfr160ehQoVo3rw5zZs3Z9myZQDUqlWLHDlykJiYyIQJE3jmmWdYv349BQsW5G9/+xsAZcuW5c4776RHjx7h80qSJGVmoY7u/2zBggXcdNNNvP/++wAMHDiQuLg4ChcuHN6nSpUq3HDDDYwYMYJ9+/aFtz/11FOMGTOGVatWRf7mJel3YPAmSf+hX49EO3DgAEOGDKF///7s2rWLOXPmMHToUDZv3sxf//rX8NvcDz/8kHXr1vHqq6/Srl070tLSyJo1KxMnTmTTpk3ExMTQs2dPRo8enRGPJUmS9Lv5dUf3o0ePhj8rU6YM2bNnZ8mSJRw9epRKlSpRo0YNNmzYEG6sADBgwABmzJhxWsjWuHFj7rzzzj/oKSTpf2fwJkn/plCL+1+PRPvll1+YOHEiI0aM4IorrqB69eo0btyY7t278/333/PBBx8ApwK6PXv2cNVVVwGwatUqrrnmGrZv3868efMAKFeuHHfdddcf+FSSJEm/j507d/Lhhx8C/+jonp6ezkMPPUSfPn3Co99KlizJzTffzLp165g1axYA3bp1Y82aNSxatCh8vlq1alGhQgWGDBnCgQMHgFNB3oQJE8INFyTpXGfwJkn/plCL+88//5yxY8eSkpJCMBjkkksuoVmzZgSDQYoUKRLev27dusTHxzNx4kQAmjRpwvHjx6lbty4NGjSgdevWNG/enJ07d9KhQ4cMeSZJkqTfy+TJk2nRogX79u1j7Nix3H777aSnp5OamsqqVatYunRpeN/ExESyZcvGrFmzCAQC1KtXj0suuYRp06axffv28H79+vUjT548ZM2a9bRrhUbUSdK5zuBNks7ibI0NFixYwGWXXUbr1q159tlnqVWrFkOGDAHg1ltvJSEhgenTp4f3v/jii6lVqxY///wzkydPpmTJknz22WfUrFmTYsWKkZSUxB133EGhQoXCDRokSZIyi1/XLvfffz958+YlPj6ehx56iJo1axIbG0uHDh04cOAAM2fODO9brlw5qlatypIlS5g/fz4A3bt3Z968eXzxxRfh/Zo3b87YsWPJmTPnadf6dRd5STpXGbxJ0j8JFZC/nk6alpbGG2+8wVVXXcXWrVuZPHky7du35/HHH2fx4sVUqFCBmjVrsnbtWhYuXBg+rl69ehQpUiTcfat27doMGDCAd955h8svvzw85SLUoEGSJOlcFwwGSU9PP6N2+dvf/sbBgwcJBoOsWbOGnj17AlC1alWuuOIKkpOTWblyZXj/xo0bs2HDhnAgl5iYSHx8PNmzZz/jmo5wk5RZGbxJEqc6bv1zAZmamsq7775LSkoKAFu2bOHDDz/kwQcfJDY2lksvvZQnn3ySG2+8kUGDBgHQsGFDcuTIEZ5aCqfe5jZq1IiWLVsSCAQIBoNER0cTDAYJBALhBYclSZLOdaFaJioqipiYGPbv388777wTXqu2U6dO7N+/H4Bx48aFjwFo06YNu3fvZtq0aeHzJScnkzdvXmbMmBFe223+/PkkJiaecW1HuEnKrLJk9A1I0rkgFICFGh3kyJGDdu3a8dFHH9G0aVMAihQpwpEjRwA4fvw42bNnp0ePHjRr1oxjx45xzTXXULVqVWbNmsWSJUuoVq0aAF27dj3jeo5wkyRJmU2oXjp+/Dhjx46lR48eFCtWjJ9++omHH36Yxx57jLi4ONq3b8+wYcNo27YtcXFxwKlR/7Vq1WLkyJEcO3aM/Pnzs2jRIp555hlKly5N9erVgVM1Unp6ukGbpPOGQy0kiVNTJp577jnKlSvHxx9/zKRJkwAYP348x44dI0uWLFx11VVMnjwZIDwFonDhwhQoUIBvvvkGODW1NCEh4Yx1SFzDTZIkZTZnm97Zt29fOnbsyBdffMGECRP45ptveP755xk1ahSfffYZAI8++ig//fQTU6dOPe3YHj168MADDzBjxgxGjx5Nq1at6NChA/Xq1TttP0M3SeeTqKC/CUq6gJztDWowGGTXrl00aNCAFi1a8MQTT/DLL7/wySef0KlTJ2bOnMlNN93EwIEDeffdd3njjTeoU6cOcKr4TEpKYubMmWeEbZIkSZnRr+ul0PRSgLfffpsOHTpQs2ZN5s6dGx4FV79+feLi4hg0aBClS5emY8eOLFiwgBkzZpArVy4mTZrEAw88AMDu3bspXLjwWc8vSecbR7xJOq+F1hUJvbENFZEHDhwI7xMVFcUPP/zAN998wz333ANAoUKF6NChA5dffjkjRowgEAjQunVrrrvuOho0aED79u1p0aIFr7/+OnffffcZoZsLAEuSpMwqVC+NHz+eFi1a0KtXL2bNmgXAfffdx1VXXUXevHlPq6fuu+8+Vq9ezZdffgnAoEGDOHDgAE2aNKFYsWJMnz6d/fv3EwgEwqFbWloacGZTK0k6nxi8STpvhAbwzps3j5o1a3Lw4MHwW9hQAfn2229z9dVXk5iYSNeuXTlx4gQA+fPnJ3fu3KxZswaAY8eOAfDwww8zbdo0kpOTKVWqFG+//TavvPIKMTExZM+enQULFtCtW7cz7sUpEpIkKbPav38/DRs25JFHHqFs2bKsX7+eLl268NZbbwHQtm1bNmzYwNdffx0+5u6776ZIkSIkJSWxbds2ChYsyJw5c+jVqxffffcdkyZNIn/+/Kc1lsqSxSXHJZ3//Ekn6byQmprKsWPHyJcvH4FAgJ49e5I3b97wVIlt27bRtWtXNm7cyAMPPECePHkYOHAgR44c4eWXX6ZAgQLUqlWLESNGUL9+fXLkyAGcehN79OhRPv30UypXrkzevHnp1KnTaR1JA4GAzRIkSVKmEupQeraXhVOmTOHo0aOsWbOGggULAlCjRg169+5NixYtePDBBxk2bBgzZ86kWrVq5MmTB4C77rqLAQMG0LhxY0qVKkXFihWpWLFi+HqAHd0lXXD8qScp0/vll1+oU6cOHTp0AKBOnTrcfvvtHDt2LByG7d+/n+rVqzN79mweffRROnTowE033cS0adOYOXMmRYoUITExkTlz5jBx4kSOHTtGMBhk8+bNNG3alLfffpvDhw+HrxkdHU0wGAwHcIZukiQpM4mOjiYmJoaDBw+ydevWcDAGsGbNGipVqkTBggXp06cPRYsW5eDBg7zwwgvExsYSGxtLq1atmDNnTrjBFEDHjh156aWXaNSo0WnXCgaDREdHG7pJuiD5k09SppcrVy7uuOMO5s+fz/79+4mOjmbFihVcf/31DB06FIASJUrwwAMPUKRIEZ555hkKFy7MqlWryJ8/Px9++CF79uzhnnvu4YEHHqB9+/bUrl2bUqVKsWTJEl599VUOHz4cnoYamtIaFRVlASlJkjKF9PT0cA0TDAY5evQoXbp0oXjx4jRp0oSuXbsCp0am/fLLLyQlJZEvXz7mzJnDsGHDWL58Oe3btw+fr3v37mzevJlPPvkkvHRHtmzZuOeee86oj3xBKelC5m+MkjKt9PR0AoEAOXLkoHHjxhQtWpQBAwYAp9Zsq1SpEp9++ikABQsWpFChQrz66qtMnTqVN998k8WLF/OXv/yF6dOnM3/+fKKjoxk8eDAzZsygUaNGDBw4kLlz57Jz505y5MjBoUOHAItHSZKUeYRGssXExBAVFcX27dtJS0tj8+bNHDlyhM8//5w2bdrwzjvv8OabbxIdHU316tX5+eef6dWrF8nJyTRr1owsWbKQkpJCz5492bRpEwUKFKBPnz40atSIbNmyZfBTStK5y+BNUqYVExNDdHQ0S5cuZeHChdx0002MHTuWtLQ0ypQpwy233MKOHTuYMGECAD/++CPjx4/n5ptvJjExEYC1a9eSlpbGhAkT+OmnnwC4/vrr6dOnD23atGH37t288sorXHPNNdx+++0Z9qySJEn/jdDoszVr1nDDDTdQpUoVbr/9du6//35uv/12rrvuOh599FF69uzJc889x9GjR2nevDkXX3wxycnJrFixgkOHDrFx40Z69+7Nhg0bOHjwIAA9evSgZs2aGfl4knTOM3iTlGnt2bOH2267jXr16rF48WLmzZvHzp07eeONNwCoXr06lStX5u9//zsAf/rTn0hJSeHEiRP8/PPPrF+/nt27d9OpUycKFiwYXhgYYPLkybRp04YyZcqwfft2XnjhBbJmzZohzylJkvTfSkpKYsSIEQwfPpybbrqJd999l5w5c7J8+XLi4uLC+3Xr1o19+/bx7rvvki9fPgYPHsyRI0eoX78+DRo04MorryQlJYVXX32VhISE8HH/vDacJOlMUcHQRH9JymTGjRtH//79+fjjj6lYsSKrV6/mySefZMOGDWzevBmAESNG8PLLLzNkyBBuu+02XnrpJd544w3S0tLYuXMnjzzyCAMGDDgjVNuwYQNz5syhevXqXHXVVRnxeJIkSf+WYDBIeno6WbJkOeOzgQMH0rt3b6pWrcrMmTOJi4sjLS2NuLg4nnrqKXr27ElsbCxwKnxLSkpi6dKl5MiRg4MHD7Jp0yZWrlxJ7dq1KVOmTPh6Lr0hSf8egzdJmdaAAQP44IMPWLt2bXjbrFmzuPfeexkwYAAdOnTgm2++oV+/fmTNmpUPP/yQQCDApk2bSE5Opn79+hQtWhQ4VUCGOm5JkiRlRidPnmTatGmULFmSK6+8kpiYGFJTU7nqqqsoUaIEn3zyCTlz5gTgiSeeYOLEicyaNYtLLrkEgM2bNxMfH88777xD27Ztzzh/IBAgGAwSExPzhz6XJGVm/oYpKdPau3cvpUuXZuvWreFtV1xxBZUrV+b1118HoHLlylx33XXMnj2b5cuXEx0dTbly5bj33nspWrRouMOXHUolSVJmlZaWRv/+/YmLi6Nv377Ur1+fTp06sXbtWmJjY2natCk///wzK1asCB/Tt29ftm7dyuzZs0lPTwegbNmydOrU6azNEkIvKA3dJOk/42+Zks4JoQ6l/47QftWrV2fr1q0sWbIk/FnRokU5efIkq1atYtKkSQDceuutjB07lquvvvq084Te2DpVQpIkZQahgOzXFi5cyKRJkxg1ahSLFy9myJAhbNy4kW7dugHQvXt3Dh8+zLx58zh+/DgAefLkoW3btgwaNIjt27eHz/XGG2/QokWLM65hvSRJ/x2DN0nnhFCH0i1btrB7925Cs+DPNhs+NDKtefPmFC1alFGjRoXDt5UrV1KwYEGuu+66cDfTKlWq0KBBgzPOYwEpSZIyk9Bos9TU1NO2T5kyhdTUVO666y5y5MjBvffey5///GcWLlzIV199RZEiRWjYsCHTpk3j22+/DR/Xr18/ihYtesbacDZMkKTfj8GbpAyRlpZ22vdbtmzh5ptv5vLLL+eOO+7g+eef/5fHh974Pv3008TExHDzzTdz6623Uq9ePcqXL8+nn37KmDFjInb/kiRJkRaqd0IvIufOnUudOnVo164d7733HnCqpkpNTaVChQqcOHEifOw111xDzZo1GT58OAA9evTgxx9/ZOrUqZw8eRKAiy++mMWLF3PRRReddl2X35Ck348/USX9oUKFY+jN6vfffw/A119/TeXKlVmwYAE1a9akb9++LFu27DdHpYXe+NaoUYMxY8bwxhtvULlyZT799FMGDhxIwYIFAd/YSpKkzCdUL4XqnaioKHbs2EG/fv1ISEgAoH379kybNo0sWbJQpEgRdu3axbJly8LnKFCgAHny5CF//vykpqZStmxZatWqddr5Q379QlSS9Puxq6mkDPHZZ5/RuXPncLODtLQ0Xn31Va644goA6tevT0xMDFOmTPmXi/ierZ29HUolSVJm9Ou65rXXXmPixInUrVuXvXv3UqlSJTp27MixY8fo3r07ixYtYs2aNWzbto2GDRtSq1YtXnrpJWJjY9m7dy/XXXcdDz/8MF26dAFOBWy/nlYqSYosgzdJERUIBIiOjg7/d9SoUaSmprJgwQJuvPFGChUqxPPPP8+ePXv4/PPPiY+PB2DevHnUq1eP5ORkqlWrdtZzp6enEx0dfVqBmp6ebrctSZKUaaWlpfHNN98wZcoUZs6cSaVKlVi2bBkrVqxgypQpNGzYEIDvvvuOSpUqMWbMGJo1a8awYcN44403yJ49O4mJiUyYMIHY2FjGjh3LJZdcEj6/Lygl6Y9l8CYp4o4fP04wGCRHjhw0btyYqVOn0rJly/AabKtXr+bKK69k8uTJNGrUKBykVa9enXLlyoXXMAn5dbi2ceNGcuXKRYkSJf64h5IkSYqA/v3789e//pWrr76aESNGUKFCBX744QcuvfRS/vrXv9K5c2eyZs0KQIsWLdiyZQuLFi0CYMWKFbz77rusXr2amjVr0rt3b0e4SVIG8zWHpN/N2dZTW7BgATfddBPvv/8+AAMHDiQuLo7ChQuH96lSpQo33HADI0aMYN++feHtTz31FGPGjGHVqlXAPxYYDoVuM2fOpGrVqjRq1IgffvghYs8lSZIUaaHxEN27d6dw4cIcO3aMP/3pTwCUKVOGVq1aMWrUKHbt2hU+5sknn2T58uVMnz4dgISEBIYMGcKcOXN4+umnyZIlS7h+kiRlDIM3Sf+zUEEXmrJw9OjR8GdlypQhe/bsLFmyhKNHj1KpUiVq1KjBhg0bwo0VAAYMGMCMGTPCIRtA48aNufPOO8PfhwK3sWPHUqlSJdq2bcvNN9/MnDlzuOGGGyL6jJIkSZEUFRVFIBCgYMGCNGnShNTUVNauXRv+/Nlnn2XlypXMnz8/HNIlJCRQtWpVZs+efdp54FR9FgwGXYJDkjKYwZuk/8rOnTv58MMPgX8EYunp6Tz00EP06dMnPPqtZMmS3Hzzzaxbt45Zs2YB0K1bN9asWROeFgFQq1YtKlSowJAhQzhw4ABwKsibMGFCuOHCxx9/TJkyZejVqxdt27bl22+/ZeDAgZQsWfIPe25JkqT/xH/TMbRbt2788ssvfPnll+HjL774Yu644w6GDx9OSkpKeN+ZM2cyZMiQM84RExPzm93hJUl/HIM3Sf+VyZMn06JFC/bt28fYsWO5/fbbSU9PJzU1lVWrVrF06dLwvomJiWTLlo1Zs2YRCASoV68el1xyCdOmTWP79u3h/fr160eePHnC65aEnDx5EjgV7PXv359169bx+OOPExcX98c8rCRJ0n8oNCottMbapk2bOHHixBmf/7NQQ6pLLrmE2rVrM2XKFDZu3Bj+vHfv3ixcuJAdO3aEt+XNmxc4+5IfkqSMZ/Am6d/y6+Lw/vvvJ2/evMTHx/PQQw9Rs2ZNYmNj6dChAwcOHGDmzJnhfcuVK0fVqlVZsmQJ8+fPB06tXzJv3jy++OKL8H7Nmzdn7Nix5MyZ87RrhQrWZs2a0bZt2zM+lyRJOteERpu9/vrrXHzxxdx5553ceuutTJky5bTPf0uPHj34/vvvSUpKCtdhVatWJSUlhYSEhDP2t0upJJ2b/Oks6V8KBoOkp6efURz+7W9/4+DBgwSDQdasWUPPnj2BUwXhFVdcQXJyMitXrgzv37hxYzZs2BAO5BITE4mPjyd79uxnXPPXiwA7TUKSJJ3Lfmu02XvvvcfLL79M7969GTZsGHnz5uWhhx5i0qRJwJk1D5wK0ILBIAkJCZQsWZKkpCT2798PnKrLChcubMMEScpEDN4knVUgECAYDBIVFUVMTAz79+/nnXfeYd68eQB06tQpXASOGzcufAxAmzZt2L17N9OmTQufLzk5mbx58zJjxozw2m7z588nMTHxjGu7CLAkScoMAoEAgUDgtNFmodFpwWCQV155hXr16vHggw9So0YNRo0aRZ06dejVqxfw2zVPqKYaP348H3zwQXh5jdDLSGslSco8smT0DUg6N4UKyOPHjzN27Fh69OhBsWLF+Omnn3j44Yd57LHHiIuLo3379gwbNoy2bduGi8LatWtTq1YtRo4cybFjx8ifPz+LFi3imWeeoXTp0lSvXh04VTymp6dbPEqSpEwpVC9t3LiRjz/+mKpVq1KpUiWKFi3K3r17yZUrF6VKlQrvny9fPjp06MCHH37I/PnzqVmz5hnBHfwjvLvooosArJckKRNzxJsk4OxTHfr27UvHjh354osvmDBhAt988w3PP/88o0aN4rPPPgPg0Ucf5aeffmLq1KmnHdujRw8eeOABZsyYwejRo2nVqhUdOnSgXr16p+1nESlJkjKjYDDIgQMH6NixI5UrV+aTTz7hvvvuo27dumzcuJH8+fMTExPDjh072LNnD3AqqCtRogQVKlQIN00IhW7BYDDcwTS0vu0/N6uSJGVOBm/SBS4UuIUCsH9uolCmTBnGjBnDjz/+SJ06dciSJQvdunWjYsWKTJ06lS1btlCyZElat27NgAED2LJlC7t372bkyJGUKFGCXr16MW3aNFavXs1dd911xvklSZIyg1AgFhJajmPp0qXMmzePBQsW8OWXX/LVV18RExND7969OXHiBImJiSQnJ7NgwYLwsbt372b9+vVUrFgROFWLhdbTDQVugwcPpkiRIrRr187RbpKUyRm8SRe4UCE3fvx4WrRoQa9evZg1axYA9913H1dddRV58+blwIED4WPuu+8+Vq9ezZdffgnAoEGDOHDgAE2aNKFYsWJMnz6d/fv3EwgEKFy4MPCPgtVGCZIkKbMIvTAMBWJ79+4F/lHPjBkzhjJlylClShUCgQAXXXQRzz77LOvXr2f69Oncd999lChRgp49e/Laa68xe/Zs+vbtS926dalQoQJwqhaLiYnh8OHDPPnkkxQqVIixY8fy0ksvsWzZMkM3ScrkDN6kC9z+/ftp2LAhjzzyCGXLlmX9+vV06dKFt956C4C2bduyYcMGvv766/Axd999N0WKFCEpKYlt27ZRsGBB5syZQ69evfjuu++YNGkS+fPnP229klDBKkmSlFmEArahQ4dSvnx5mjZtymuvvca2bdsAyJ49O/v37ydbtmzhkK5JkyZER0ezePFicubMyYgRI7jtttsYN24crVu3plChQowcOTK8Nm56ejq9e/cmb968LF26lLfffpvly5fTpk0bcuTIkTEPLkn63UQFnfclnfdCHUrP9sb0vffe4+2332bChAkULFgQgBo1arBhwwY2bdpEtmzZqFy5MnfccQd9+/YlT548AAwbNowBAwYwcuRIbr/99jOuB5yxULAkSVJmkZaWRlJSEitXrmTatGk0a9aM9evXM2vWLMqWLcvUqVOZMmUKiYmJrFu3jvj4eE6ePEnWrFm57bbbyJ07Nx9++GH4fLt37yZXrlzkzJkT+Md01ePHjzNp0iSKFStGnTp1MupxJUkR4hAU6QIQCsAOHjzI/v37KVmyZHjbmjVrqFSpEgULFqRPnz689dZbFCtWjBdeeIHY2FhiY2Np1aoVn376KU2aNOH6668HoGPHjsTFxdGoUaPTrhUMBg3cJElSpvFbLww//fRTunbtSo4cOXjuuedo2bIlANOnT6dZs2ZMnjyZRo0aUbVqVbp06cK4ceMoUKAAGzduZNu2bTz55JOnnS+0/EZoPbfQ9bJnzx4+tyTp/ONvx9J5KD09PTzdIRgMcvToUbp06ULx4sVp0qQJXbt2BU4Vmr/88gtJSUnky5ePOXPmMGzYMJYvX0779u3D5+vevTubN2/mk08+4cSJEwBky5aNe+6554wi1TXcJElSZhIdHU10dDQ//vgjixYtCm9v2rQp119/PSkpKVx99dXh7TVr1iQxMZHnn3+emJgYXn/9ddatW8f1119P27ZtqVmzJkWKFDmjk3tITEyMLykl6QLiT3zpPBJ6YxsTE0NUVBTbt28nLS2NzZs3c+TIET7//HPatGnDO++8w5tvvkl0dDTVq1fn559/plevXiQnJ9OsWTOyZMlCSkoKPXv2ZNOmTRQoUIA+ffrQqFEjsmXLlsFPKUmS9N/75w6lwWCQw4cP06pVKypXrkxiYiJdu3blu+++IyoqKtw4au7cueFjcuXKRZ06dTh06BBbt24lISGB6dOn8+ijj5IlSxZee+015syZQ7FixTLi8SRJ5xjXeJPOQ2vWrOHBBx/k22+/5dprr2Xv3r088cQTJCYmAtCnTx9Gjx7Nhg0bOHnyJLVr1+ZPf/oTTz/9NPHx8ezcuZMXXniBrVu38sILL5CQkJDBTyRJkvS/SU9PP22925UrV1K2bFm++eYb3nvvPZ5++mk++eQTRo8eTUJCAsOHD+fIkSPcfvvtFCxYkJEjR5I/f34AHn/8cebOnUtSUlJ4/dv/63qSpAuTI96k80hSUhIjRoxg+PDh3HTTTbz77rvkzJmT5cuXhztnAXTr1o19+/bx7rvvki9fPgYPHsyRI0eoX78+DRo04MorryQlJYVXX331tNAtNKJOkiQpswmFYCtWrKBcuXLceOON3HbbbTz55JNUr16d4sWL07lzZxITE0lKSmL58uXkypWLJk2aMHfuXLp3705ycjLJycnMnTuXunXrnjV0S09PP+16kqQLmyPepEwmGAySnp5Olixn9kYZOHAgvXv3pmrVqsycOZO4uDjS0tKIi4vjqaeeomfPnsTGxgKnwrekpCSWLl1Kjhw5OHjwIJs2bWLlypXUrl2bMmXKhK/num2SJCkzOVv9MmvWLP72t79Ro0YNUlNTadiwIc899xxjxoxhyZIlVK1aFYBly5bxxBNPUK5cOUaMGMGePXto3Lgxmzdv5oYbbmD16tVce+21DB069LQXm5IknY3Bm5RJnTx5kmnTplGyZEmuvPJKYmJiSE1N5aqrrqJEiRJ88skn4Xb1TzzxBBMnTmTWrFlccsklAGzevJn4+Hjeeecd2rZte8b5A4EAwWDQt7WSJCnT+Ff1y9SpU2ncuDGXXnops2bNolSpUmzevJnWrVtTqlQpxo8fD5yqsQYOHMiECRP4+OOPiY+P59lnn2XhwoXce++9tG7dOnxOX1BKkv4vTjWVMpm0tDT69+9PXFwcffv2pX79+nTq1Im1a9cSGxtL06ZN+fnnn1mxYkX4mL59+7J161Zmz54dnv5QtmxZOnXqdNZmCcFgkOjoaEM3SZKUqYTql927dzNhwgS2b98e7sh+7bXXcscddxAXF0epUqUAKFWqFG3btmXGjBls3boVgKxZs1K3bl0ABg8eDECbNm04ePAgK1euDHeOT0tLM3STJP2fDN6kc1QoIPu1hQsXMmnSJEaNGsXixYsZMmQIGzdupFu3bgB0796dw4cPM2/ePI4fPw5Anjx5aNu2LYMGDWL79u3hc73xxhu0aNHijGtYREqSpMxo+/bt3HPPPZQrV45+/fpxyy238MQTTwBQoEAB2rRpw6JFi9i4cSNwKmSrVasW5cqVC4dsAAkJCbRv354mTZoAUKZMGWrXrs3cuXOZPXs2wFmX/ZAk6dcM3qRzVGi0WWpq6mnbp0yZQmpqKnfddRc5cuTg3nvv5c9//jMLFy7kq6++okiRIjRs2JBp06bx7bffho/r168fRYsWPaNItGGCJEnKDLZs2QKcGpmflpZ2xue7d+9m0KBBpKamsmDBAlatWsXQoUMZOnQo8+fPJzo6mjp16pCQkMBzzz0XPq5s2bK0bNmS119/nX379gGQK1cuHn30URo0aBAe4daqVSsuu+wyLrroosg/rCTpvGHwJp0jQiPcQsXd3LlzqVOnDu3ateO9994DTk1pSE1NpUKFCuFpEwDXXHMNNWvWZPjw4QD06NGDH3/8kalTp3Ly5EkALr74YhYvXnxGsRgd7Y8BSZJ0bnvxxRe58847WbduHVFRUeEXiQcPHgzvkz9/fq6++mreeustKleuzKJFixgyZEj4+FDDqW7dujFu3Dh27doFQGxsLHXr1uXBBx/kyJEjp103EAiEZwJUqVKFMWPGcPnll/8RjyxJOk/4G7eUwUJBW2iEW1RUFDt27KBfv34kJCQA0L59e6ZNm0aWLFkoUqQIu3btYtmyZeFzFChQgDx58pA/f35SU1MpW7YstWrVOu38IWd7QyxJknQuCtUx5cuXJ1euXHz22WcAjB49mmrVqnHXXXfx0UcfcejQIbJmzUqrVq3IkiULrVu3plWrVsTHxzN27FimTZvGggULALjtttsoXrw4vXr1Cl8nISGB4cOHU7JkydOu7wtKSdL/yoUJpAwS6oIVeov62muvMXHiROrWrcvevXtp27YtHTt25NixY+TMmZMnnniC2267jXbt2vHRRx8xbtw4rrnmGmJjY9m3bx/ffvstt9xyC7GxsQC8++67Z117xPVIJElSZhAIBEhPTydr1qw0aNCAKVOmsGDBAooUKcKYMWNo3rw5ixcvpm/fvuzcuZPu3buTLVs2xo4dy8aNGxk/fjzXX389W7ZsIV++fIwZM4aaNWtStGhRHnnkEXbs2HHGNdPT020uJUn6XUUFfz0cRtIfJi0tjW+++YYpU6Ywc+ZMKlWqxLJly1ixYgVTpkyhYcOGAHz33XdUqlSJMWPG0KxZM4YNG8Ybb7xB9uzZSUxMZMKECcTGxjJ27FguueSS8PmDwWC4Q6kkSVJmEQgEwvXLkSNHCAQCzJs3j4EDB3Lw4EH69OlDy5YtOXr0KI8//jirVq3igw8+oFSpUjRu3JjU1FRmzpwJwAcffEDv3r3ZsmULy5cvD88okCTpj+Bv41IGGjBgADVq1GDOnDn8/e9/Z8SIEUyYMIEsWbKwadOm8Pps5cuX58477+Sll14CoFu3bowZM4ZatWoxd+5cmjRpwpdffnla6Aanpq0aukmSpMwmOjqanTt30rFjR+Lj43n66aepUaMGpUuX5qeffuKWW24BIGfOnDRo0ID09PTwmriNGzdm9uzZvPLKKwwZMoQhQ4YwevRoJk2adFroFgwGbTIlSYo4R7xJGSA0zXTPnj1UrVqVwoUL88UXX5AjRw4A2rVrx+rVq5kyZUq4GcKKFSuoVq0an376KQ0aNDjtPCFOj5AkSeeD5cuX06JFC+Lj4+nRowcxMTHUqVOH999/n+eee44ePXrQoUMH4FSDhccff5z169czefJk8ufPT7du3Vi2bBl79uzhz3/+M/fff38GP5Ek6ULlUBgpA0RFRREIBChYsCBNmjQhNTWVtWvXhj9/9tlnWblyJfPnzw8vKpyQkEDVqlWZPXv2aeeBU4FbMBg0dJMkSeeFDz74gHLlyjF9+nTq1atHnTp1ALj55pu57LLLmDFjBsePHwcgb9683HzzzRw9epSRI0cCMGTIEKZMmcLGjRsN3SRJGcrgTfod/TcdQ7t168Yvv/zCl19+GT7+4osv5o477mD48OGkpKSE9505cyZDhgw54xwxMTGnjXyTJEnKzGJjY1m9ejULFy5k8ODBDBw4kM6dO7Nt2zZuvPFGdu3axaeffhre/8Ybb6Rs2bIcOXIkfHzhwoUBO7pLkjKWU02l38Gvp3xu2rSJkiVLki1btrN+HhJaOLh169bs3LmToUOHctlllwGwbNkyqlWrdtZFgP95wWFJkqTzTUpKCi1atGD9+vXUqFGDYDDIDz/8QCAQoGPHjsydO5eYmBjGjRsXPubQoUPkyZMnA+9akqQzZcnoG5DOB6FQ7fXXX+eFF14gLi6OAgUK8Nhjj9G4ceP/czRajx49aNq0KUlJSVSoUIGoqCiqVq1KSkpK+G3tPzN0kyRJ57OiRYsyefJkcufOzYEDB8ifPz9RUVFky5aN0qVLU7FiRWbPns2GDRu49NJLAciTJ48d3SVJ5xz/RZL+Q7/V/eq9997j5Zdfpnfv3gwbNoy8efPy0EMPMWnSJODUOmy/Fh0dTTAYJCEhgZIlS5KUlMT+/fuBU6PkChcufNbjJEmSznd58+YlOjqanDlzEhUVxfDhw7nyyiupVKkSPXv2ZN68eeHQLcSO7pKkc41TTaV/Uyhw++diLjSFNBgMUrVqVa655hrefPNNAPbt20ePHj1ITk7m22+//c3zhjqR/vTTTxQvXtxiUZIkCUhNTWXSpElMnz6d5ORkDh48yIsvvkibNm3CNZjLb0iSznX+KyX9m6Kjo4mOjmbjxo288MILzJkzh127dgGwd+9ecuXKRalSpcL758uXjw4dOrBt2zbmz58PnH20XCj7vuiii4iOjnaEmyRJEqcaJJQtW5bcuXPTv39/duzYQZs2bYB/LPNh6CZJOtf5L5X0bwgGgxw4cICOHTtSuXJlPvnkE+677z7q1q3Lxo0byZ8/PzExMezYsYM9e/YApwrBEiVKUKFCBTZu3BjeFjpfqMNWliynllpcunRpBjyZJEnSuatq1aoMGzaMli1bAnYolSRlPgZv0q/8uqALTWVYunQp8+bNY8GCBXz55Zd89dVXxMTE0Lt3b06cOEFiYiLJycksWLAgfOzu3btZv349FStWBE5NK01PTycqKiocuA0ePJgiRYrQrl278LRTSZIk/WNkW2jWQKh+kiQpszB4k/6/0JTPUEG3d+9e4B8F35gxYyhTpgxVqlQhEAhw0UUX8eyzz7J+/XqmT5/OfffdR4kSJejZsyevvfYas2fPpm/fvtStW5cKFSoAEBMTQ0xMDIcPH+bJJ5+kUKFCjB07lpdeeolly5YZukmSJJ2FU0olSZmV/4JJ/18oYBs6dCjly5enadOmvPbaa2zbtg2A7Nmzs3//frJlyxYO6Zo0aUJ0dDSLFy8mZ86cjBgxgttuu41x48bRunVrChUqxMiRI4mLiwNOjXjr3bs3efPmZenSpbz99tssX76cNm3akCNHjox5cEmSJEmSFBF2NZU4Nb00KSmJlStXMm3aNJo1a8b69euZNWsWZcuWZerUqUyZMoXExETWrVtHfHw8J0+eJGvWrNx2223kzp2bDz/8MHy+3bt3kytXLnLmzAn8Y7rq8ePHmTRpEsWKFaNOnToZ9biSJEmSJOkPYPCmC0pofZBfT1f4+OOP6dq1Kzly5OC5554LL+A7ffp0mjVrxpgxY2jUqBE1atQgd+7cjBs3jgIFCrBx40buvPNOnnzySVq3bn3G9ULruTk9QpIkSZKkC4/Bmy5IP/74Izt27KB69erAqRFpd911FzNmzGDFihWUL18egCNHjtClSxfWr1/P4sWLWbFiBY0bNyZ37txce+21zJo1i4oVKzJmzBiKFSuWkY8kSZIkSZLOMQ7D0XntnzuUBoNBDh8+TKtWrahcuTKJiYl07dqV7777jqioKJo0aUKxYsWYO3du+JhcuXJRp04dDh06xNatW0lISGD69Ok8+uijZMmShddee405c+YYukmSJEmSpDMYvOm8lJ6eDvyjQ+nKlSs5dOgQq1atIm/evGzYsIE+ffqwfPlyXn75ZQDuvPNOSpcuzdy5c9m/f3/4XGvXriVHjhzhBgmVK1fmwQcf5O9//zvNmjU77XqSJEmSJEkhWTL6BqRIiImJAWDFihU0b96cHTt2cOWVVwLQoUMHihcvTufOnTl8+HC4s+jVV19NkyZNeOaZZ+jevTtdunQBYO7cudStW5c8efKccZ309HRiYmLC15MkSZIkSQpxxJsyvbMtUzhr1iyaN2/OwoUL6dSpE8uWLaNMmTJ89dVXVKpUKbxfnTp1KF68OCNHjgSgVatWlC9fntmzZ/PXv/6Ve++9l8suu4xevXqd9doGbpIkSZIk6bc44k2ZViAQIBgMnjX8OnnyJBMmTOCbb75h1qxZlCpVimeeeYZNmzYxePBgxo8fD8AVV1xB7dq1mTBhAt9//z3x8fHceuutLFy4kKZNmzJx4sTwOYPBIFFRUX/Y80mSJEmSpMzNEW/KtKKjo4mJiWH37t1MmDCB7du3c+LECQCuvfZa7rjjDuLi4ihVqhQApUqVom3btsyYMYOtW7cCkDVrVurWrQvA4MGDAWjTpg0HDx5k5cqV4dF0aWlphm6SJEmSJOk/YvCmTGv79u3cc889lCtXjn79+nHLLbfwxBNPAFCgQAHatGnDokWL2LhxI3AqZKtVqxblypULh2wACQkJtG/fniZNmgBQpkwZateuzdy5c5k9ezbwjyYNkiRJkiRJ/y6DN52TtmzZApya3pmWlnbG57t372bQoEGkpqayYMECVq1axdChQxk6dCjz588nOjqaOnXqkJCQwHPPPRc+rmzZsrRs2ZLXX3+dffv2AZArVy4effRRGjRoEB7h1qpVKy677DIuuuiiyD+sJEmSJEk6Lxm86Zzz4osvcuedd7Ju3TqioqLCo80OHjwY3id//vxcffXVvPXWW1SuXJlFixYxZMiQ8PFpaWnExcXRrVs3xo0bx65duwCIjY2lbt26PPjggxw5cuS06wYCgfB00ipVqjBmzBguv/zyP+KRJUmSJEnSecjgTeeM0Giz8uXLkytXLj777DMARo8eTbVq1bjrrrv46KOPOHToEFmzZqVVq1ZkyZKF1q1b06pVK+Lj4xk7dizTpk1jwYIFANx2220UL178tK6kCQkJDB8+nJIlS552/eho/3eQJEmSJEm/H5MGnRMCgUB4SmmDBg0oX748CxYsYNSoUbz//vs0b96cfPny0bdvX0aNGgVAtmzZ+Oijj9i4cSPjx4/n1VdfpXr16uTLl48xY8aQnp5O0aJFeeSRRyhUqNAZ10xPT/8jH1GSJEmSJF1gooKhYUZSBgkEAuHRZkeOHCEQCDBv3jwGDhzIwYMH6dOnDy1btuTo0aM8/vjjrFq1ig8++IBSpUrRuHFjUlNTmTlzJgAffPABvXv3ZsuWLSxfvpyEhISMfDRJkiRJknQBc8SbMlx0dDQ7d+6kY8eOxMfH8/TTT1OjRg1Kly7NTz/9xC233AJAzpw5adCgAenp6bz33nsANG7cmNmzZ/PKK68wZMgQhgwZwujRo5k0adJpoVswGCQQCGTI80mSJEmSpAtTloy+AWn58uW0aNGC+Ph43nvvPWJiYoiLi6Nhw4asXLmSSZMm0aFDBwBq1qzJlClTmDlzJl26dOGBBx5g9erVjBs3jj179vDnP/+ZGjVqnHGNqKiocOMESZIkSZKkP4JTTZXhevbsybp165g2bdpp21NSUujcuTPR0dG8//77ZM+eHYAJEybwwgsv0KxZM5544glSU1M5cOAAhQsXzojblyRJkiRJOiunmirDxcbGsnr1ahYuXMjgwYMZOHAgnTt3Ztu2bdx4443s2rWLTz/9NLz/jTfeSNmyZTly5Ej4+FDoFmrQIEmSJEmSlNEc8aYMl5KSQosWLVi/fj01atQgGAzyww8/EAgE6NixI3PnziUmJoZx48aFjzl06BB58uTJwLuWJEmSJEn611zjTRmuaNGiTJ48mdy5c3PgwAHy589PVFQU2bJlo3Tp0lSsWJHZs2ezYcMGLr30UgDy5MlDMBgkGAyGO6JKkiRJkiSdSxzxpnPKiRMnyJYtG8OHD2fUqFFMmDCB/PnzExsbS7Zs2TL69iRJkiRJkv5tjnjTOSE1NZVJkyYxffp0kpOTOXjwIC+++CKlSpUiGAwSFRVFIBBwdJskSZIkSco0DN50ToiNjaVs2bLkzp2b/v3707Jly/BnUVFRAIZukiRJkiQpU3Gqqc4ZoZFtIWlpaWTJYjYsSZIkSZIyJ4M3nXOcUipJkiRJks4HBm+SJEmSJElSBDisSJIkSZIkSYoAgzdJkiRJkiQpAgzeJEmSJEmSpAgweJMkSZIkSZIiwOBNkiRJkiRJigCDN0mSJEmSJCkCDN4kSZIUVrp0aV555ZX/6Rz9+/fnyiuv/F3uR5IkKTOLCgaDwYy+CUmSJP2xRo0axSOPPML+/ftP2757925y5cpFzpw5/+tzHz58mBMnTlCwYMH/8S4lSZIytywZfQOSJEk6dxQuXPh/Pkfu3LnJnTv373A3Z5eamkpsbGzEzi9JkvR7caqpJElSJnTixAkeeughihQpQvbs2bnxxhtZunQpAElJSURFRTF16lSqVKlC9uzZqV69OmvWrAl/3r59ew4cOEBUVBRRUVH0798fOHOqaVRUFCNGjKBRo0bkzJmTyy67jOTkZL7//ntq165Nrly5uP7669m0aVP4mF9PNQ1d45//lC5dOvz5mjVraNCgAblz56Zo0aK0adOGX375Jfx57dq16datG4888giFChWifv36v/9fqCRJUgQYvEmSJGVCTzzxBBMnTmT06NF8/fXXxMfHU79+ffbu3Rve5/HHH+ell15i6dKlFC5cmMaNG3Py5Emuv/56XnnlFfLmzcuOHTvYsWMHPXv2/M1r/eUvf+Hee+9l5cqVVKhQgVatWvHggw/y1FNPsWzZMoLBIN26dfvN40PX2LFjB99//z3x8fHUrFkTgP3791O3bl0SEhJYtmwZM2bMICUlhebNm592jtGjRxMbG8uXX37Jm2+++T/+7UmSJP0xnGoqSZKUyRw5coThw4czatQoGjRoAMBbb73F7Nmz+fvf/84111wDwNNPP83NN98MnAquSpYsyaRJk2jevDn58uUjKiqKYsWK/Z/Xa9++fTgIe/LJJ7nuuuvo27dveOTZww8/TPv27X/z+NA1gsEgiYmJ5MuXjxEjRgAwbNgwEhISeP7558P7v/3225QqVYrvvvuO8uXLA1CuXDlefPHF/+jvSZIkKaM54k2SJCmT2bRpEydPnuSGG24Ib8uaNSvVqlXj22+/DW+77rrrwl8XKFCASy+99LTP/11VqlQJf120aFEAKleufNq248ePc/DgwX95nl69epGcnMzkyZPJkSMHAKtWrWLevHnhdeFy585NhQoVws8ZcvXVV//H9y1JkpTRHPEmSZKkfylr1qzhr6Oion5zWyAQ+M1zvP/++7z88sskJSVx0UUXhbcfPnyYxo0b88ILL5xxTPHixcNf58qV679/AEmSpAziiDdJkqRM5pJLLgmvdxZy8uRJli5dSsWKFcPbFi1aFP563759fPfdd1x22WUAxMbGkp6e/ofcb3JyMh06dGDEiBFUr179tM+uuuoq1q5dS+nSpYmPjz/tj2GbJEnK7AzeJEmSMplcuXLRuXNnHn/8cWbMmMG6devo2LEjR48e5f777w/v9+yzzzJnzhzWrFlDu3btKFSoEE2aNAFOdS89fPgwc+bM4ZdffuHo0aMRudedO3fStGlTWrRoQf369dm5cyc7d+5k9+7dAHTt2pW9e/fSsmVLli5dyqZNm5g5cybt27f/w4JBSZKkSDF4kyRJyoQGDRpEYmIibdq04aqrruL7779n5syZxMXFnbbPww8/zNVXX83OnTuZMmUKsbGxAFx//fV06tSJu+++m8KFC0esccH69etJSUlh9OjRFC9ePPwn1ACiRIkSfPnll6Snp3PLLbdQuXJlHnnkEfLnz090tKWqJEnK3KKCwWAwo29CkiRJv5+kpCTq1KnDvn37yJ8/f0bfjiRJ0gXL14iSJEmSJElSBBi8SZIkSZIkSRHgVFNJkiRJkiQpAhzxJkmSJEmSJEWAwZskSZIkSZIUAQZvkiRJkiRJUgQYvEmSJEmSJEkRYPAmSZIkSZIkRYDBmyRJkiRJkhQBBm+SJEmSJElSBBi8SZIkSZIkSRHw/wBbZSpFI6Fm/QAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo_momentum\", \"shampoo_momentum_diagonal\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between convergence times of shampoo (momentum) diagonal and non-diagonal on CIFAR10\"\n",
+    "save_path = f\"diagrams/convergence_times_shampoo_momentum_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_convergence(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "b9f87198",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2538760060.py:30: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo_heuristic\", \"shampoo_heuristic_diagonal\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between convergence times of shampoo (heuristic) diagonal and non-diagonal on CIFAR10\"\n",
+    "save_path = f\"diagrams/convergence_times_shampoo_heuristic_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_convergence(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9681411",
+   "metadata": {},
+   "source": [
+    "## Experiment 7: Time for 30 epochs on MNSIT"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "d57b9452",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2149615011.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\", \"adam\", \"sgd\", \"adagrad\"] \n",
+    "dataset = \"mnist\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between total runtimes on MNIST\"\n",
+    "save_path = f\"diagrams/run_times_shampoo_total_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_total_runtime(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50fabf98",
+   "metadata": {},
+   "source": [
+    "## Experiment 8: Time for 100 epochs on CIFAR"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "8826d609",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\nicol\\AppData\\Local\\Temp\\ipykernel_18700\\2149615011.py:26: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  collected_data = pd.concat([collected_data, df], axis=0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers = [\"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\", \"adam\", \"sgd\", \"adagrad\"] \n",
+    "dataset = \"cifar\"\n",
+    "save_figure = True\n",
+    "title = \"Comparison between total runtimes on CIFAR\"\n",
+    "save_path = f\"diagrams/run_times_shampoo_total_{dataset}.png\"\n",
+    "\n",
+    "create_diagram_total_runtime(optimizers, dataset, save_figure, title, save_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "caf934b4",
+   "metadata": {},
+   "source": [
+    "## Experiment 9: Time for a single step"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "9ba360f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x700 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "optimizers_to_experiment = [\"adam\", \"shampoo\", \"shampoo_momentum\", \"shampoo_heuristic\",  \"adagrad\", \"sgd\"]\n",
+    "csv_path = \"metrics/update_step_times.csv\"\n",
+    "title = \"Single-step update time (best-case per optimizer)\"\n",
+    "save_figure = True\n",
+    "save_path = \"diagrams/update_step_times_single_bar.png\"\n",
+    "\n",
+    "create_diagram_single_step_times(\n",
+    "    optimizers_to_experiment=optimizers_to_experiment,\n",
+    "    csv_path=csv_path,\n",
+    "    title=title,\n",
+    "    save_figure=save_figure,\n",
+    "    save_path=save_path,\n",
+    "    log_y=False\n",
+    ")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_cifar.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_cifar.csv
new file mode 100644
index 00000000000..dc9d2de6a1f
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_cifar.csv
@@ -0,0 +1,200 @@
+1.0,2.3525176693534826,0.19775,1.9770877563459692,0.293,16.5627894
+2.0,1.9933757631578697,0.2695,1.8840920123801166,0.344,16.6632955
+3.0,1.8870275557811433,0.308,1.7521898954412172,0.376,14.8111079
+4.0,1.838970319968048,0.336375,1.7512402029759484,0.374,16.892236
+5.0,1.7983652051171501,0.340125,1.7041614743772173,0.388,16.754057
+6.0,1.7639884846916494,0.3545,1.7007192082181473,0.3955,16.86898
+7.0,1.7319906151869124,0.366125,1.6643657475232014,0.409,14.6980181
+8.0,1.7191399331441288,0.373625,1.6373385765855297,0.4185,16.3787913
+9.0,1.6887798888521173,0.38525,1.6247596532802018,0.422,17.306563
+10.0,1.6672638569618237,0.39425,1.6055093821160877,0.429,14.2644272
+11.0,1.6665822245964574,0.399625,1.5959366377877726,0.422,16.9012201
+12.0,1.6321231822018958,0.404125,1.5911652494434338,0.435,16.331345
+13.0,1.6292060855513437,0.404375,1.569968237291539,0.433,14.2357001
+14.0,1.6173664812640651,0.411875,1.573168766000019,0.4315,16.6200638
+15.0,1.601948287376504,0.422125,1.5639267426632981,0.432,16.5488731
+16.0,1.586624438732671,0.426,1.54796353376094,0.439,14.3659882
+17.0,1.5725416457812533,0.435,1.539033627431622,0.45,16.5512762
+18.0,1.5532761360416096,0.437125,1.524467721275078,0.458,16.7252311
+19.0,1.5595854207480837,0.435125,1.532617831374849,0.4425,14.5641253
+20.0,1.538996952942756,0.446375,1.5285537500809663,0.446,17.2230119
+21.0,1.5244963543482677,0.4445,1.5060030565980103,0.4585,15.5399189
+22.0,1.5126671155875087,0.45,1.4962624770808604,0.4605,17.4517569
+23.0,1.5004406972098523,0.453875,1.490774199710812,0.4675,16.9830095
+24.0,1.5021516280984601,0.453875,1.49692226304672,0.4555,15.2614663
+25.0,1.5046980711946587,0.44975,1.4909535115207777,0.4625,16.6510473
+26.0,1.4987544437050875,0.455125,1.490582223454174,0.459,16.3281718
+27.0,1.496482960699866,0.456375,1.484370200958131,0.4695,17.2861647
+28.0,1.4756829616121314,0.45925,1.482418154824619,0.47,14.7729577
+29.0,1.4881953088733133,0.4635,1.4807136536364471,0.4645,16.6669683
+30.0,1.483057305027351,0.4645,1.4795846860110935,0.4645,14.7511868
+31.0,1.481815361210857,0.460375,1.4758836190558693,0.468,17.0824707
+32.0,1.4678794376871414,0.46775,1.4668043826805486,0.4665,15.0721681
+33.0,1.4789399877260598,0.456,1.4711883389739473,0.472,17.4713719
+34.0,1.4696075265521034,0.469875,1.4740084141767413,0.4675,14.6646385
+35.0,1.4592000361680788,0.471875,1.4647200522222603,0.479,16.438427
+36.0,1.457949154383233,0.47175,1.458910719801983,0.4755,14.3605564
+37.0,1.4615357962803135,0.47025,1.461752917273364,0.469,16.3856965
+38.0,1.4502747025172773,0.47525,1.4524352612785438,0.4765,14.3639238
+39.0,1.4434251046909914,0.4775,1.4602360342528944,0.469,16.6219119
+40.0,1.4520996688608636,0.4735,1.4516321615056214,0.475,14.521727
+41.0,1.4356953031915525,0.479125,1.4471805673066738,0.476,17.6061949
+42.0,1.4416382488223645,0.479875,1.4487727943504154,0.4735,14.8936368
+43.0,1.419821307034743,0.4805,1.4433121038737087,0.4735,16.5566491
+44.0,1.4412459171886698,0.482,1.4419434097272106,0.471,14.4456632
+45.0,1.4206351749422363,0.482875,1.4420560005907708,0.478,16.5090784
+46.0,1.427818734353288,0.483125,1.4401025958486915,0.474,14.8036235
+47.0,1.4118638992319366,0.487875,1.4419370666643578,0.4715,16.5244424
+48.0,1.4252813631822019,0.483875,1.4395151384905942,0.478,14.5789258
+49.0,1.4236445988372677,0.483125,1.4384802625889306,0.4755,16.6160785
+50.0,1.4261732252972659,0.479125,1.4397222232368654,0.4785,14.5616705
+51.0,1.4238656382573633,0.48275,1.4363463359005815,0.479,16.6296362
+52.0,1.4239042005569045,0.488375,1.4385283858343663,0.481,14.5668062
+53.0,1.4305294544785423,0.481625,1.439548235446059,0.48,17.3996059
+54.0,1.4205174230253133,0.4805,1.43667797999367,0.48,15.8467494
+55.0,1.4080313534480295,0.48775,1.4340066773788451,0.477,16.9779644
+56.0,1.4146674190926325,0.488875,1.4319104588441534,0.482,14.7299725
+57.0,1.4139867868157547,0.482,1.4329599010241207,0.475,17.7724898
+58.0,1.4093299058615778,0.4905,1.4335421713779317,0.476,14.9524934
+59.0,1.4069872831508183,0.48925,1.4323913300198619,0.479,18.1339098
+60.0,1.4163295678457235,0.485625,1.4342323177408987,0.48,14.7339361
+61.0,1.4095672453980637,0.486375,1.4277494128014663,0.4815,16.5034787
+62.0,1.4183395970526305,0.486375,1.4279411233570136,0.479,14.8745913
+63.0,1.4130114738160957,0.48725,1.4290096579669855,0.48,17.3033572
+64.0,1.4173513545054441,0.487125,1.4272822594228691,0.4835,15.0599621
+65.0,1.4061681520281595,0.48975,1.4273514022034381,0.4775,16.6086364
+66.0,1.3976200739984572,0.49775,1.4277960409740174,0.4835,14.6020738
+67.0,1.40539641803699,0.488875,1.4263319594739419,0.481,17.0219255
+68.0,1.4105072196823203,0.49075,1.4264601321064592,0.478,15.1955381
+69.0,1.3993882698871267,0.497375,1.4250042167037364,0.481,17.2519572
+70.0,1.404642869999872,0.495625,1.4252706241981246,0.4795,14.4923314
+71.0,1.3967142987876306,0.4985,1.4258612818599872,0.48,16.9620813
+72.0,1.400187992610452,0.488875,1.4246276841276857,0.4805,15.1828176
+73.0,1.4010515367252945,0.493875,1.4272030287893707,0.4825,16.5832672
+74.0,1.399228047073277,0.497375,1.4267764024243845,0.4815,14.7613969
+75.0,1.4030520699726876,0.497875,1.4253007732510028,0.4795,17.6440231
+76.0,1.399824070278591,0.491375,1.4245226187869138,0.4825,14.8281107
+77.0,1.412786803852016,0.490375,1.4244650732397273,0.484,16.8367306
+78.0,1.3929641885561934,0.4925,1.4231586480311238,0.485,14.92643
+79.0,1.3969132253207723,0.486375,1.4241087063683102,0.4855,16.5440243
+80.0,1.4031105064842928,0.495875,1.4240680865571633,0.4815,14.5422601
+81.0,1.3870001945109223,0.502125,1.4230744676442548,0.4825,16.585134
+82.0,1.3900491647367241,0.494625,1.422347248876832,0.4805,14.5175986
+83.0,1.394854410522665,0.495625,1.4217029164524788,0.4845,16.5488756
+84.0,1.3909479029784875,0.499125,1.421873877859747,0.484,14.6124514
+85.0,1.3961408600953606,0.48775,1.423681401888568,0.4825,16.4699679
+86.0,1.3907893229411876,0.493625,1.4224449417402814,0.4815,14.4806338
+87.0,1.3856733758328978,0.4995,1.4226265081217038,0.484,16.6598808
+88.0,1.4043383889954333,0.487,1.4227207753991766,0.483,14.6675403
+89.0,1.3894401485366061,0.495,1.4216512851048158,0.486,16.7446401
+90.0,1.3902714780747547,0.493,1.4203838352807379,0.4845,14.6216061
+91.0,1.3924528485596925,0.48925,1.4208424756194165,0.4855,16.5701578
+92.0,1.3883207966011577,0.49825,1.4213182100013309,0.485,14.599584
+93.0,1.3869024440462996,0.498,1.4215526970935568,0.4845,16.6413091
+94.0,1.3926793073903623,0.494125,1.421794685300093,0.482,14.7032887
+95.0,1.3849892234720413,0.502875,1.4213110023027338,0.485,16.5647276
+96.0,1.3951784683373474,0.49725,1.4205429855006968,0.4845,14.5230985
+97.0,1.3847455015367232,0.500625,1.4204793593467593,0.4835,17.5136281
+98.0,1.3894493038071352,0.5065,1.4207048776349356,0.483,16.1148827
+99.0,1.3994931355862779,0.4915,1.4207444664786022,0.4835,16.6138513
+100.0,1.3913930899634372,0.493875,1.4203442290191703,0.4825,14.911277
+101.0,1.3903311323806034,0.496375,1.4201929039052001,0.483,17.0301776
+102.0,1.3876392684230898,0.49575,1.4205152979850322,0.481,14.7764801
+103.0,1.3874238109432417,0.49775,1.42033235325581,0.4835,16.8832686
+104.0,1.3943769398127774,0.49775,1.4204923108630083,0.483,14.4454207
+105.0,1.3875553081538905,0.49575,1.4203373340150247,0.4835,16.5732949
+106.0,1.3969151488584617,0.4955,1.4209582931795133,0.48,15.4472906
+107.0,1.3898139424399516,0.490625,1.4215538532981564,0.4815,17.7494321
+108.0,1.3786830514071766,0.50175,1.4216497080026897,0.4825,15.4477677
+109.0,1.3977240374414541,0.49575,1.4207883378362078,0.482,17.6681097
+110.0,1.3936217002111093,0.499,1.4200655538549016,0.482,14.9656849
+111.0,1.3825219744286266,0.497,1.4207092003589215,0.481,17.765571
+112.0,1.387493314681766,0.496875,1.4204708431542872,0.4825,14.9594406
+113.0,1.3924749159769572,0.49775,1.4201978892506029,0.483,16.5427203
+114.0,1.3818777768056631,0.50275,1.4197815263335865,0.4825,14.8762161
+115.0,1.3814729453755257,0.500375,1.4193649239597823,0.4825,16.5971656
+116.0,1.3886886805799392,0.5025,1.4196729163539097,0.483,14.4330551
+117.0,1.3881796560792075,0.49375,1.4194590473297288,0.482,16.4168809
+118.0,1.3908856659539928,0.497375,1.4201308696520343,0.482,14.4764822
+119.0,1.384240270889367,0.505875,1.419440675452351,0.483,16.4101799
+120.0,1.388919293317496,0.497,1.4193308146014278,0.482,14.4690208
+121.0,1.3986924679816948,0.498875,1.4196637053584589,0.482,16.4386084
+122.0,1.3889829028434624,0.497,1.419563050588049,0.482,14.7886559
+123.0,1.3942914866106508,0.493625,1.419882588243892,0.481,17.2829424
+124.0,1.383490268351106,0.495625,1.4194286110705912,0.482,14.5395305
+125.0,1.389164044346411,0.49225,1.419255924174284,0.482,17.4748786
+126.0,1.3874639612284996,0.49925,1.4193708745356666,0.4815,15.1802834
+127.0,1.3943531787210013,0.492875,1.4193856484983538,0.4825,16.6639913
+128.0,1.3921740863497931,0.49475,1.419605113329245,0.482,14.5265674
+129.0,1.3932032848660056,0.493,1.4200459606131384,0.482,16.5375928
+130.0,1.3898133661451104,0.495375,1.4199204312932654,0.483,14.438044
+131.0,1.3855799501516712,0.493875,1.419513481185195,0.4825,16.6287285
+132.0,1.3848330248933314,0.49675,1.4193595387932403,0.484,14.5286568
+133.0,1.3900889247927195,0.49275,1.4192824703564728,0.4835,16.5296859
+134.0,1.3877471210638928,0.50125,1.4194082164191502,0.4835,14.4177796
+135.0,1.3813838383241765,0.496,1.4192262931620134,0.4825,16.7108967
+136.0,1.383339205496465,0.500875,1.419071878356233,0.4835,14.3275267
+137.0,1.3831614832512582,0.493,1.4190144949503698,0.4835,17.8683737
+138.0,1.3821740758485448,0.503125,1.4187708540934292,0.482,15.3725553
+139.0,1.3863805356472663,0.50025,1.4188086050200772,0.4825,17.3630713
+140.0,1.3802485324002565,0.49725,1.4189913685728113,0.4835,14.6267963
+141.0,1.3778295269516136,0.504375,1.418931278526175,0.4825,17.0603967
+142.0,1.3815899878894171,0.496375,1.4187655782190225,0.4825,14.2855367
+143.0,1.3821424982535808,0.497375,1.41872191834974,0.4825,15.9036716
+144.0,1.3894945008603652,0.49625,1.4187668846010224,0.4825,15.7109337
+145.0,1.3764020922766245,0.5075,1.4187202523852742,0.4835,16.9488475
+146.0,1.379902589274272,0.494625,1.4187541713085412,0.4825,14.504533
+147.0,1.3832440260284533,0.498125,1.418731830549829,0.482,16.6324517
+148.0,1.3851122868441257,0.496125,1.4188619396503406,0.482,14.752616
+149.0,1.375324937585105,0.5055,1.4188282362461424,0.482,17.0242684
+150.0,1.3895955870273244,0.501625,1.4189121559763842,0.482,14.7874068
+151.0,1.3680250195610848,0.511375,1.4188819963699155,0.4815,16.4870867
+152.0,1.3885675961840862,0.49675,1.418945029739514,0.482,14.5347894
+153.0,1.3859650656853826,0.49725,1.419043637954077,0.4815,16.42935
+154.0,1.389403962978957,0.497875,1.4190787651456018,0.4815,14.4587694
+155.0,1.3864140087406989,0.4985,1.4191561820107543,0.4815,16.487036
+156.0,1.3922009176885077,0.4985,1.4190642106668645,0.4815,14.5079904
+157.0,1.3857670237530713,0.49975,1.4190182435968117,0.4815,16.9465767
+158.0,1.3838295688453517,0.494125,1.418832683594518,0.482,14.4941984
+159.0,1.3854287876173728,0.49575,1.4187978199154139,0.4815,16.4123438
+160.0,1.384218970051715,0.491125,1.4188375039047352,0.481,14.7512277
+161.0,1.381961095899816,0.495875,1.4188396352865056,0.481,17.2117211
+162.0,1.3857848185022583,0.499875,1.41882179584504,0.481,15.5351325
+163.0,1.386667614513884,0.496875,1.4187454730782443,0.4815,16.8494892
+164.0,1.392392807864532,0.496875,1.418776140526483,0.481,14.7307964
+165.0,1.3876796759991565,0.499375,1.4188737864472032,0.4815,16.3173796
+166.0,1.3872415425569036,0.502875,1.4188572364429302,0.4815,14.3415462
+167.0,1.3866273597320402,0.493875,1.4188521785463761,0.4815,16.3284575
+168.0,1.3865864755634443,0.502625,1.4188630163575122,0.4815,14.3397091
+169.0,1.3830770754488284,0.50375,1.4188664276754117,0.4815,16.2989853
+170.0,1.3854146179160034,0.5045,1.4188988184440194,0.4815,14.3043123
+171.0,1.384239302782733,0.49725,1.41895353593278,0.4815,16.3149244
+172.0,1.3756087065749183,0.4995,1.4189692431403655,0.481,14.2901696
+173.0,1.389838759401308,0.502625,1.418946758892231,0.482,16.3190489
+174.0,1.3827961170278658,0.499,1.4189487382700445,0.482,14.3389146
+175.0,1.3840676521455315,0.497625,1.4189460967491951,0.482,16.2668354
+176.0,1.3859403161379191,0.503875,1.4189776238798362,0.482,14.3243646
+177.0,1.3887439238924346,0.499375,1.4189947486908006,0.482,16.2845361
+178.0,1.3876554812617177,0.49575,1.4189810439893475,0.482,14.3670207
+179.0,1.381968757077724,0.49725,1.418926971978386,0.482,16.2894068
+180.0,1.3936226462124568,0.498125,1.4188776851021236,0.482,14.3436526
+181.0,1.3789572014987692,0.494125,1.41885664842968,0.482,16.3309314
+182.0,1.3881823089993017,0.494625,1.4188511663312806,0.482,14.3087881
+183.0,1.3852339640780342,0.4995,1.418890486299103,0.482,16.2456632
+184.0,1.3813461110148502,0.4945,1.4188549171897107,0.482,14.3369703
+185.0,1.3818342396949286,0.494375,1.4188338665273819,0.482,16.2939532
+186.0,1.3892124188612416,0.49525,1.418846640882808,0.482,14.322679
+187.0,1.3812301252303896,0.494375,1.4188179913341572,0.482,16.2958307
+188.0,1.3814830043580946,0.507125,1.418824427486655,0.482,14.3439149
+189.0,1.3990099036117098,0.49,1.4188605429049523,0.482,16.3186364
+190.0,1.3897803545227114,0.494375,1.4188697141790827,0.482,14.34814
+191.0,1.3910870890594529,0.499125,1.41886857467969,0.482,16.3464144
+192.0,1.3860926926724169,0.502,1.4188939979824764,0.482,14.2963438
+193.0,1.3830831335672908,0.50275,1.4188993782347343,0.4815,16.2862901
+194.0,1.382888155158363,0.5045,1.4188807092586129,0.4815,14.396975
+195.0,1.382834499988602,0.49825,1.4188686272614945,0.4815,16.278158
+196.0,1.3833894553684116,0.501125,1.4188712972416067,0.482,14.3342256
+197.0,1.3807217241419694,0.502875,1.4188878529802946,0.4815,16.293994
+198.0,1.3927900512815214,0.49025,1.4189061340117721,0.4815,14.3463528
+199.0,1.3926960505422254,0.49375,1.418886502610954,0.4815,16.2829646
+200.0,1.3779264053198463,0.506375,1.4188526982043426,0.4815,14.3254612
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_cifar.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_cifar.csv.mtd
new file mode 100644
index 00000000000..27ebbad6ff3
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_cifar.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 200,
+    "cols": 6,
+    "nnz": 1200,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-15 19:30:46 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_mnist.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_mnist.csv
new file mode 100644
index 00000000000..f9812bfc241
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_mnist.csv
@@ -0,0 +1,30 @@
+1.0,0.8174863545185341,0.774875,0.5278741425441658,0.84,10.1715735
+2.0,0.391795059625804,0.894875,0.41137626379303716,0.872,10.4089369
+3.0,0.3238912468355683,0.908875,0.3622260650084861,0.882,10.3654082
+4.0,0.2876961379383318,0.91825,0.3313803292772612,0.895,10.3783455
+5.0,0.2628983787077953,0.924,0.30862959093366016,0.902,10.4308053
+6.0,0.2441301997304852,0.930875,0.2907272547557681,0.909,10.4656414
+7.0,0.22922833829299888,0.93575,0.2756156963141336,0.915,10.4514486
+8.0,0.2169527598480045,0.938125,0.26295870228302826,0.92,10.4143988
+9.0,0.20646154584633128,0.940375,0.2518751846043149,0.923,10.4375515
+10.0,0.19738738897718835,0.9425,0.24216711870097585,0.924,10.4102107
+11.0,0.18935859648693504,0.9445,0.23361393594884702,0.926,10.4084565
+12.0,0.18222128259203033,0.9475,0.22597548108970147,0.929,10.4346495
+13.0,0.17576497728562024,0.94875,0.2190843598622689,0.93,10.4568538
+14.0,0.1699038875106924,0.95075,0.21289983296694728,0.933,10.4100527
+15.0,0.164577939692685,0.952875,0.2072369736645604,0.937,10.4324912
+16.0,0.1597495354557598,0.95425,0.20204653194347794,0.938,10.426407
+17.0,0.15532033631119696,0.955875,0.19733096208156406,0.942,10.4358339
+18.0,0.1512202977597111,0.95725,0.19293555460197345,0.943,10.4476537
+19.0,0.14743331410629051,0.958,0.18883545199137233,0.944,10.4798371
+20.0,0.14386068327115994,0.95925,0.1850174321646986,0.944,10.4543712
+21.0,0.14051337203274358,0.96025,0.18145676836312086,0.947,10.4729614
+22.0,0.137373666192189,0.96125,0.17815738488515756,0.948,10.4414544
+23.0,0.1344302826236057,0.962125,0.17504792923854812,0.949,10.4334216
+24.0,0.13165543256604695,0.962875,0.1720851788402324,0.949,10.4474674
+25.0,0.129021950918666,0.96325,0.16910255182294232,0.95,10.4655045
+26.0,0.12648997237758286,0.963375,0.16622084441698967,0.955,10.4872578
+27.0,0.1240750267160454,0.964375,0.1636150063159457,0.956,10.4448993
+28.0,0.12178406969154447,0.965125,0.1612286673708566,0.957,10.4340736
+29.0,0.11967929529435148,0.965875,0.15901937095827254,0.959,10.4108645
+30.0,0.11768908388467672,0.966625,0.15699640830982067,0.959,10.4343964
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_mnist.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_mnist.csv.mtd
new file mode 100644
index 00000000000..4f8918c902b
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_adagrad_mnist.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 30,
+    "cols": 6,
+    "nnz": 180,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 08:34:44 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_adam_cifar.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_adam_cifar.csv
new file mode 100644
index 00000000000..267143d2235
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_adam_cifar.csv
@@ -0,0 +1,200 @@
+1.0,2.2849196751628265,0.189875,2.084519199828603,0.2405,14.7279931
+2.0,2.0514378323125824,0.252625,1.98933459881626,0.292,12.0516347
+3.0,1.9483185388915683,0.285,1.8908715936959504,0.316,12.0382224
+4.0,1.8657670224907221,0.31925,1.8231926858817933,0.3505,11.8445111
+5.0,1.8133863519594728,0.34075,1.7555661572244337,0.375,11.8414297
+6.0,1.7752940536772115,0.361125,1.7451762129659305,0.38,11.9849105
+7.0,1.7412140907682303,0.364875,1.675082659913595,0.3945,12.2866462
+8.0,1.703594517521442,0.38625,1.6755534277474669,0.3945,12.1006226
+9.0,1.67629931872254,0.3825,1.6453974387727168,0.4175,12.1520741
+10.0,1.6503038838775324,0.40425,1.6527344115405305,0.403,12.2163826
+11.0,1.6046312956693347,0.42075,1.615644343841738,0.426,12.1007201
+12.0,1.6057910018134771,0.416,1.6214707453859993,0.412,12.1328547
+13.0,1.5803807420278695,0.427125,1.6334525156054494,0.4185,12.0758261
+14.0,1.5601278394115907,0.44125,1.6344749209002323,0.4105,11.9790827
+15.0,1.5415127588392297,0.44225,1.5742071180868544,0.435,12.0774245
+16.0,1.5310840346940542,0.445,1.5827404127899867,0.4285,11.9541701
+17.0,1.501572988672101,0.4545,1.5341685757260721,0.456,12.2120863
+18.0,1.485450600681299,0.460125,1.5477966198027597,0.447,12.2838707
+19.0,1.4639507843093702,0.469375,1.5037428814070453,0.464,12.3109653
+20.0,1.4624581517072426,0.475125,1.5087492133926155,0.4575,12.1374387
+21.0,1.424003268593148,0.479125,1.4637703031331817,0.476,12.0712177
+22.0,1.4075127554733322,0.49675,1.447448027473934,0.483,12.3378606
+23.0,1.3972850105580534,0.4925,1.4424116465037955,0.4775,12.2581617
+24.0,1.400391795640922,0.49625,1.4279798056071022,0.488,12.6511055
+25.0,1.379568500469636,0.5065,1.422323027619446,0.499,12.5493209
+26.0,1.3770498202977532,0.5025,1.4112297227561756,0.49,12.7169776
+27.0,1.3773478962375088,0.501875,1.4094591034438153,0.5,12.9440793
+28.0,1.372900634925617,0.50075,1.4278028238885263,0.486,12.9146473
+29.0,1.3509242459451736,0.511,1.4129524924866912,0.492,13.0256457
+30.0,1.348270725670394,0.51225,1.4100022427744408,0.4895,12.9327142
+31.0,1.3329985225173466,0.51525,1.3920069168097868,0.5045,12.7132853
+32.0,1.3251132878547367,0.5295,1.4052131459513406,0.4905,13.0306638
+33.0,1.3209339033459857,0.5275,1.4140671696405032,0.489,12.6107867
+34.0,1.3248265628032125,0.527375,1.3888975383542994,0.5025,12.7180129
+35.0,1.3068804444938087,0.530625,1.3771416602724549,0.5085,12.8326966
+36.0,1.2985978187007923,0.527625,1.3835900063973818,0.5115,13.431879
+37.0,1.2870060080982069,0.536,1.3730847447029817,0.4975,13.5859462
+38.0,1.2988105916353487,0.531375,1.381673182657721,0.506,13.400477
+39.0,1.2880745925084696,0.539875,1.395685755681152,0.5005,13.8126345
+40.0,1.2775779295535075,0.54325,1.3648056632917787,0.505,13.2916727
+41.0,1.2674003729198933,0.54425,1.355786253462423,0.5195,13.4106837
+42.0,1.2403405311431046,0.551,1.3450661914225202,0.525,12.9386497
+43.0,1.2525224138791935,0.542875,1.350498716202372,0.523,12.7960323
+44.0,1.2436083667132574,0.550125,1.3505262990520448,0.515,12.4925015
+45.0,1.2219492901922577,0.56425,1.3441768377315926,0.5245,12.4754613
+46.0,1.2314550412956364,0.553125,1.3479888063293441,0.5205,12.5148793
+47.0,1.2336214417836706,0.555875,1.338068259159096,0.517,12.6374146
+48.0,1.2103050046512716,0.56025,1.340510380329518,0.5185,12.6743832
+49.0,1.219686015987277,0.560875,1.3370040043704807,0.5185,12.8179449
+50.0,1.2004770007335606,0.569375,1.3409828430072768,0.5235,12.8586987
+51.0,1.2132168302149613,0.567625,1.3392852350306141,0.5245,12.5285519
+52.0,1.210763052483666,0.565125,1.3251450455748024,0.531,12.7817476
+53.0,1.2068689256609306,0.567875,1.3396422423345984,0.531,12.5246526
+54.0,1.2003869651458665,0.563625,1.3397842845150154,0.524,12.518152
+55.0,1.1897083944117914,0.571375,1.3326517121353787,0.521,12.5286551
+56.0,1.1907082749491233,0.57225,1.323745174568078,0.5245,12.5858061
+57.0,1.1827624610749325,0.57875,1.3351505769504648,0.5235,12.5630183
+58.0,1.187010866248019,0.57325,1.3302752936400533,0.528,12.6256623
+59.0,1.1808579575072458,0.573125,1.321112577063071,0.5245,12.6291565
+60.0,1.1709501378424008,0.5795,1.3193550707370911,0.532,12.638679
+61.0,1.1618246093018365,0.5795,1.3174784735123832,0.5355,12.5791721
+62.0,1.1520319609034644,0.585375,1.3150433637399883,0.538,12.6202631
+63.0,1.1477539630405775,0.5875,1.318354816281638,0.531,12.6393164
+64.0,1.1560321916756717,0.583,1.3096614796084618,0.5365,12.8598063
+65.0,1.1409984315346478,0.5915,1.3128574701046716,0.5345,12.6252
+66.0,1.1425714072096107,0.5865,1.3209965747790466,0.5365,12.6533994
+67.0,1.1377979615331564,0.586375,1.3141779951201742,0.538,12.7527022
+68.0,1.1401642573887183,0.59575,1.311253411803279,0.5405,12.7049227
+69.0,1.1285763022611082,0.597625,1.3137751559893571,0.538,12.6332984
+70.0,1.1252280895811295,0.605,1.3144801123311738,0.5345,12.7263709
+71.0,1.1293086454489187,0.59475,1.3097648977770586,0.5345,12.6680093
+72.0,1.1202055671663882,0.601,1.3103034184189035,0.5355,12.7294065
+73.0,1.134320745341683,0.59225,1.3072929819696633,0.5365,12.7053955
+74.0,1.1177024220508391,0.608875,1.3112032049465983,0.539,12.7136953
+75.0,1.1154503437470824,0.59725,1.311733976116678,0.5375,13.5584812
+76.0,1.1052320532715771,0.60275,1.3073616569960127,0.5365,13.4558369
+77.0,1.1194800737647423,0.5995,1.3091582262531305,0.541,14.8243635
+78.0,1.1050994531956013,0.602,1.312880202348314,0.537,14.627551
+79.0,1.1158452230823257,0.60125,1.313914357285414,0.5335,14.2486491
+80.0,1.1038506503516912,0.608625,1.3050348758083008,0.5395,14.7808327
+81.0,1.0953394125932696,0.611125,1.3141482311854404,0.537,14.0316975
+82.0,1.1011376756848144,0.603375,1.3070462300718728,0.54,14.7576307
+83.0,1.0901740272336728,0.606125,1.3045036073733352,0.532,14.3377276
+84.0,1.0940842569842533,0.6065,1.302985038443557,0.538,13.4949199
+85.0,1.096499247425454,0.607375,1.3057020850092418,0.5355,13.6330622
+86.0,1.1029016463254413,0.608125,1.3062685187921292,0.5385,13.7520263
+87.0,1.1022467567036578,0.60825,1.3059329122970975,0.537,13.4987059
+88.0,1.0970637078902337,0.61075,1.3068760309206455,0.534,13.3646162
+89.0,1.0785672019494184,0.614125,1.3027072107401472,0.534,13.3917491
+90.0,1.080712426820526,0.612875,1.3058378744825552,0.5385,13.392417
+91.0,1.0883703299628775,0.61925,1.305967016726914,0.5355,13.4042449
+92.0,1.0956831660720512,0.60625,1.3054116425434836,0.5415,13.4848434
+93.0,1.094387999136863,0.61275,1.3038351010661038,0.5395,13.3700216
+94.0,1.0816361054881438,0.61525,1.302473732099717,0.5305,13.7820103
+95.0,1.084442501275727,0.607625,1.3075599661465238,0.535,13.3721083
+96.0,1.0672284004847896,0.61975,1.300113948680686,0.5325,13.7785516
+97.0,1.0810702022912604,0.616875,1.30007005088398,0.536,13.2700695
+98.0,1.074312475895865,0.61825,1.305057674824402,0.5385,13.5271689
+99.0,1.07787518971787,0.613375,1.3049000745872636,0.5375,13.3081504
+100.0,1.0622463948112089,0.617,1.3047937546047945,0.535,13.3883841
+101.0,1.0798863145626965,0.614125,1.300087975852338,0.5385,13.2879323
+102.0,1.0748581762085905,0.614875,1.3020408251579965,0.5425,13.4267144
+103.0,1.076131837119873,0.6145,1.3018864601505626,0.539,13.6095403
+104.0,1.0698148614793446,0.620875,1.300722831486062,0.539,13.704695
+105.0,1.0574729051032306,0.622,1.2997871976737332,0.5395,13.4815717
+106.0,1.0632482421212033,0.61475,1.3002700108382346,0.5345,13.4054907
+107.0,1.0747349356106042,0.61025,1.3026416420735858,0.5395,13.5249073
+108.0,1.0540256979272413,0.623875,1.301327355702955,0.5395,13.4147966
+109.0,1.0630822063016014,0.61725,1.3003957520698923,0.5455,13.6041269
+110.0,1.0684277335644676,0.606375,1.3029070250525718,0.5395,13.4500564
+111.0,1.0595024475081802,0.62575,1.3033425554955833,0.541,13.390854
+112.0,1.061014467865129,0.61475,1.3032459363385156,0.537,13.4080771
+113.0,1.0702669986594389,0.616875,1.299287772058609,0.538,13.3726651
+114.0,1.0625400138511465,0.61475,1.3003511425879692,0.5385,13.2651985
+115.0,1.0537797004118257,0.619375,1.3017929379372826,0.542,13.2452856
+116.0,1.0547080024448152,0.62175,1.3006155344670178,0.536,13.2166823
+117.0,1.072237912575877,0.61375,1.3015528750320164,0.54,13.2115493
+118.0,1.067022205702234,0.6155,1.3027222626760364,0.539,13.2426751
+119.0,1.0628803732045762,0.61675,1.3017082699813987,0.5405,13.1901532
+120.0,1.0690572401899596,0.61525,1.3027649923054705,0.54,13.2637659
+121.0,1.0586669193834752,0.623375,1.3006300467231307,0.5365,13.4097789
+122.0,1.0707946270681614,0.617125,1.2974340390217514,0.5375,13.250331
+123.0,1.051137950774137,0.627625,1.3010242838026764,0.5395,13.1804708
+124.0,1.0541840286720705,0.623875,1.3002439660513028,0.539,13.2243373
+125.0,1.0607372145414002,0.625625,1.2988381891129452,0.5365,13.2615272
+126.0,1.0560736430132651,0.61875,1.3001726010873673,0.5425,13.2503012
+127.0,1.051659583298328,0.621625,1.2985708239702267,0.539,13.3604874
+128.0,1.0606420874136282,0.618875,1.2988845125118098,0.5405,13.2487604
+129.0,1.0501140126272774,0.620125,1.298684961646278,0.54,13.2934161
+130.0,1.0522953186407882,0.619875,1.2994599738514365,0.541,13.2823787
+131.0,1.0482259552664168,0.627375,1.2988166707261257,0.5395,13.2011415
+132.0,1.053630483315171,0.625625,1.297500298847332,0.542,13.2469529
+133.0,1.0496909241863799,0.623875,1.2982112761444378,0.542,13.2440761
+134.0,1.053390944540559,0.61975,1.2970349452301133,0.538,13.2768969
+135.0,1.0617769307692633,0.621125,1.295577652776914,0.5375,13.3100702
+136.0,1.046344593896457,0.6255,1.2971494371345131,0.5405,13.5443696
+137.0,1.0400885286166677,0.623875,1.2982766618245636,0.54,13.5714783
+138.0,1.0472142246630913,0.630125,1.297338078921211,0.5395,13.4726551
+139.0,1.044345956063719,0.62725,1.2996330963054585,0.5395,13.4786256
+140.0,1.0421961727437798,0.626,1.2981433616708402,0.5405,13.5379465
+141.0,1.06094211532486,0.620875,1.2975984703287131,0.5395,13.7041342
+142.0,1.0553657128652232,0.62425,1.2974125710982907,0.5385,13.6269432
+143.0,1.042882076126943,0.62475,1.2966133401698707,0.5425,13.3839252
+144.0,1.038168211893101,0.626125,1.296318973292743,0.543,13.4427766
+145.0,1.043062231991865,0.62825,1.2973188627296,0.5385,13.4143434
+146.0,1.05010651570851,0.623625,1.296283899633047,0.5415,13.4953181
+147.0,1.0395164948182658,0.630125,1.2976354042279787,0.5425,13.3437978
+148.0,1.0500351886047596,0.620625,1.2972685062147329,0.543,13.5782792
+149.0,1.0471942017101314,0.627875,1.296841270490122,0.544,13.3897592
+150.0,1.040091049062549,0.626,1.2961824055017408,0.5455,13.5886698
+151.0,1.0472366745104382,0.6215,1.2959668583369286,0.5445,13.4912199
+152.0,1.0392867299480801,0.6275,1.296922447744704,0.544,13.4204069
+153.0,1.050994383234715,0.62375,1.2961989924721584,0.5405,13.2335554
+154.0,1.0446272673308703,0.6255,1.296787939931907,0.5425,13.0050197
+155.0,1.0440555151791635,0.62025,1.2964212823829375,0.5405,13.4590827
+156.0,1.0493211434094583,0.622,1.2968609932044313,0.5425,13.4093477
+157.0,1.0370568091941397,0.632375,1.2967308597633744,0.542,13.3970959
+158.0,1.0558573769633197,0.616625,1.2969991442357738,0.5415,13.4566714
+159.0,1.0383749175601147,0.633125,1.295994288564952,0.5415,13.3690832
+160.0,1.0415060230094486,0.633,1.2964085846075386,0.54,13.4282967
+161.0,1.0470905127873347,0.622125,1.296114744568239,0.5395,13.3444574
+162.0,1.031406022430593,0.6315,1.2960618765544158,0.539,13.4295613
+163.0,1.0511886537754764,0.622625,1.2956914380859437,0.541,13.6733833
+164.0,1.039775700268689,0.6225,1.2957488263350172,0.537,13.5702263
+165.0,1.0544922164917554,0.62425,1.2957468170564426,0.5395,13.3902833
+166.0,1.034979644714843,0.628375,1.2958221039568119,0.539,13.4432765
+167.0,1.0391553788499304,0.624875,1.295842786471535,0.54,13.3949436
+168.0,1.0404343953468584,0.63025,1.295914241832399,0.542,13.5573102
+169.0,1.0523678651269004,0.62525,1.2958358142973219,0.543,13.3908004
+170.0,1.0446434167572052,0.6275,1.2953615693678218,0.541,13.3952878
+171.0,1.0417704010479667,0.625875,1.2957523613885806,0.541,13.3884274
+172.0,1.0517252803838033,0.61825,1.295786228869096,0.5405,13.4192946
+173.0,1.03768060965457,0.63025,1.2954580883629132,0.541,13.3358693
+174.0,1.041155215478498,0.625875,1.296008407969002,0.5435,13.4552215
+175.0,1.045112281407261,0.624375,1.296169606537798,0.543,13.535416
+176.0,1.033650008698053,0.62875,1.296262316562349,0.541,13.4594821
+177.0,1.0510810913616209,0.624375,1.2962449321777039,0.5415,13.51468
+178.0,1.0433757721788466,0.622125,1.2956677720818424,0.5385,13.6767805
+179.0,1.051224348660264,0.621875,1.2960152149763833,0.5405,13.5006381
+180.0,1.0314177794277277,0.62875,1.2964203689113176,0.5385,13.5067165
+181.0,1.0513367570179246,0.6295,1.2958561900007526,0.54,13.3785868
+182.0,1.0412040258844728,0.62925,1.2960574313662299,0.539,13.3887546
+183.0,1.0443543257450396,0.625125,1.296019282055106,0.5395,13.5726541
+184.0,1.0544053821073291,0.62475,1.2957639155633933,0.539,14.2769559
+185.0,1.0423633805872128,0.6325,1.2959458594657913,0.54,13.3224801
+186.0,1.0445996463405407,0.625125,1.29606694455465,0.5395,13.2358042
+187.0,1.0465690668191656,0.62925,1.296345247773905,0.5395,13.2132424
+188.0,1.0494627804918446,0.62325,1.2961809356557625,0.5395,13.2491389
+189.0,1.0463956346701941,0.6285,1.296215486088509,0.54,13.2674834
+190.0,1.0403554510497814,0.625125,1.296261999020853,0.5405,13.3292092
+191.0,1.0398717612085016,0.62425,1.296240204862022,0.5395,13.2973548
+192.0,1.0385983015407974,0.629,1.2957113332142651,0.5405,13.2913105
+193.0,1.049133429011457,0.624,1.2958224601839807,0.5405,13.2628486
+194.0,1.0433478935994807,0.629375,1.2958572548832248,0.5405,13.3001396
+195.0,1.0545677217104032,0.62175,1.2956059549931291,0.54,13.2969423
+196.0,1.026881556699914,0.628625,1.2957579917984832,0.5405,13.45485
+197.0,1.051392938570302,0.623125,1.2955728910405828,0.5405,13.4111643
+198.0,1.0438591114221216,0.62775,1.295647149201594,0.54,13.5004065
+199.0,1.0363710844857252,0.629625,1.295381574037537,0.539,13.4280088
+200.0,1.0307854527842486,0.631,1.2954949267970077,0.539,13.4776295
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_adam_cifar.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_adam_cifar.csv.mtd
new file mode 100644
index 00000000000..0037962551d
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_adam_cifar.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 200,
+    "cols": 6,
+    "nnz": 1200,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-15 12:46:32 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_adam_mnist.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_adam_mnist.csv
new file mode 100644
index 00000000000..60534e100a4
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_adam_mnist.csv
@@ -0,0 +1,30 @@
+1.0,0.671490737144344,0.7822380952380952,0.47648379728190243,0.843,11.0895268
+2.0,0.25421095633431173,0.922,0.28867533486183933,0.918,10.0406482
+3.0,0.17652634164175846,0.94975,0.2141941434112847,0.929,9.5463554
+4.0,0.13149718153185025,0.960125,0.17720437481290172,0.942,9.4036622
+5.0,0.10283253683514162,0.96875,0.14575266474294093,0.953,9.2312427
+6.0,0.0857641404536416,0.973125,0.12156059472284547,0.964,9.1185585
+7.0,0.07526608123779649,0.975,0.13143898826790207,0.956,9.009549
+8.0,0.06621729533058522,0.9775,0.12712797771017936,0.956,8.990172
+9.0,0.05638331247547828,0.981875,0.12373785148374339,0.964,8.7923934
+10.0,0.04905036295398357,0.98325,0.12886071132992316,0.964,8.7588239
+11.0,0.04177406893518381,0.98675,0.13889555161434866,0.96,8.7338741
+12.0,0.037331166043982976,0.98775,0.14846274898559222,0.959,8.7932293
+13.0,0.032232535710503385,0.98975,0.1303295757283838,0.964,8.7249633
+14.0,0.02814180253320607,0.991125,0.11611641280607592,0.973,8.8053534
+15.0,0.025252820878453777,0.992625,0.12700909663005708,0.966,8.6906225
+16.0,0.02354666703378057,0.993375,0.1282420152545264,0.967,8.6754428
+17.0,0.024105774394357852,0.993,0.15015425935971588,0.961,8.6436733
+18.0,0.02508707503139239,0.992625,0.14032983320639303,0.965,8.4945501
+19.0,0.030871324030576203,0.989875,0.12607367953398993,0.963,8.3992487
+20.0,0.02737566527843638,0.990375,0.23582806890127408,0.945,8.2508794
+21.0,0.03523152484880446,0.987625,0.1957042110747224,0.95,8.2963981
+22.0,0.02078805290051819,0.9935,0.1479263583651629,0.963,8.2306996
+23.0,0.014928886045055035,0.995875,0.10446953685296069,0.973,8.275324
+24.0,0.011105806741145708,0.9965,0.08355163540486386,0.976,8.298743
+25.0,0.012849094119188423,0.99575,0.10836928291824617,0.972,8.2758025
+26.0,0.011429991318525302,0.997,0.07273887235172055,0.978,8.469496
+27.0,0.010144580112965642,0.997125,0.07333669203604924,0.982,8.3406143
+28.0,0.009408933052245154,0.997125,0.0873327717081945,0.976,8.340315
+29.0,0.010256818646241157,0.996625,0.09984224770745295,0.973,8.3268913
+30.0,0.008459429296304744,0.997625,0.07754990695275935,0.976,8.317416
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_adam_mnist.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_adam_mnist.csv.mtd
new file mode 100644
index 00000000000..d8e436dd0a0
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_adam_mnist.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 30,
+    "cols": 6,
+    "nnz": 180,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 08:10:05 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_cifar.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_cifar.csv
new file mode 100644
index 00000000000..1bdb7e4ba9f
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_cifar.csv
@@ -0,0 +1,200 @@
+1.0,2.317499911691124,0.169375,2.13424996174316,0.2015,15.667751
+2.0,2.098735588520919,0.22975,1.9912422098606615,0.278,15.1149278
+3.0,2.0097480363784372,0.2715,1.8862427334879692,0.329,15.4429617
+4.0,1.9514673308758173,0.301375,1.879526135571271,0.331,15.5616138
+5.0,1.871795416876061,0.324,1.771293949699762,0.3695,15.7251895
+6.0,1.8425656402886006,0.330375,1.7664795366108683,0.378,14.3086093
+7.0,1.800303919378991,0.34875,1.8639381882569974,0.358,16.9555352
+8.0,1.8012275932260025,0.355875,1.791716958522556,0.371,16.6882911
+9.0,1.7412280970305518,0.383375,1.6950311909952513,0.4135,14.6615754
+10.0,1.7427920276002093,0.377,1.6618712129189341,0.4025,16.2223382
+11.0,1.7031177660760168,0.391375,1.6446194865177897,0.4145,14.2083057
+12.0,1.6763181012684694,0.39375,1.627796724004429,0.418,15.9863267
+13.0,1.665250053617422,0.404375,1.5874945013185404,0.434,13.9179277
+14.0,1.6389400351200059,0.4135,1.6347278525690576,0.4305,15.5785975
+15.0,1.8796133430068205,0.35125,1.6321659876571426,0.437,15.0555681
+16.0,1.6976884158676238,0.399375,1.6231041802537918,0.425,15.8103506
+17.0,1.6321263797709322,0.41475,1.5880290447377179,0.433,13.7301958
+18.0,1.6170722018143378,0.4255,1.5555519893435967,0.451,15.3379314
+19.0,1.5865396398926177,0.434375,1.582015763206702,0.446,13.6175248
+20.0,1.5920473401056938,0.4315,1.567473467273074,0.439,15.224785
+21.0,1.5058687231131618,0.459125,1.4664476723421473,0.478,13.1470106
+22.0,1.4740327894056129,0.472875,1.4357962065188545,0.488,15.2127073
+23.0,1.4632867476778213,0.478,1.4512076441018342,0.48,13.3270302
+24.0,1.4581241812276582,0.47475,1.4215735227706199,0.4955,13.6533707
+25.0,1.4401845236680246,0.48525,1.4424898768758543,0.48,13.679977
+26.0,1.4456110648690073,0.48675,1.4283706213878717,0.4845,13.6214922
+27.0,1.453133943225923,0.479625,1.431633205175132,0.481,13.6292351
+28.0,1.423656330734472,0.490375,1.414020911190374,0.4975,13.5491708
+29.0,1.4134631194803782,0.492125,1.40227521208565,0.49,13.6603128
+30.0,1.4187313979517304,0.49175,1.4175029234205387,0.5035,13.4406988
+31.0,1.4083973484354269,0.492125,1.4051559993054898,0.5015,13.6087809
+32.0,1.3925444389739492,0.501375,1.4072171059975653,0.4945,13.4785072
+33.0,1.394413466584004,0.498125,1.405395410616994,0.5035,13.2013823
+34.0,1.3800512338529545,0.506875,1.422614904690278,0.4865,13.5603503
+35.0,1.3926589200018364,0.497625,1.413254526080061,0.499,13.4163224
+36.0,1.379245965884372,0.514125,1.3864508892392262,0.5115,13.428615
+37.0,1.365956871328199,0.50875,1.4106641268222693,0.494,13.4418634
+38.0,1.3682513628232957,0.503125,1.3814346416604908,0.5075,13.4559156
+39.0,1.3650905934219062,0.516375,1.3777762784596113,0.508,13.341786
+40.0,1.3554101647885188,0.519875,1.4064793629265897,0.4985,13.3609986
+41.0,1.3011859261215395,0.539625,1.3546267019469518,0.527,13.3448237
+42.0,1.2758903018078527,0.54775,1.3442981257376423,0.528,13.5570786
+43.0,1.3038593944073782,0.52875,1.358259080997001,0.5265,13.4646088
+44.0,1.2907539193635258,0.54725,1.3482157723566228,0.5265,13.425172
+45.0,1.2664903832365444,0.544875,1.349655587237188,0.527,13.5045013
+46.0,1.2774463194611307,0.55025,1.3414804211297133,0.532,13.8650976
+47.0,1.2602868014242223,0.547625,1.3411393583185882,0.528,13.8070153
+48.0,1.2589074254721981,0.550375,1.3352796166181973,0.529,13.7642676
+49.0,1.2613348719275195,0.545375,1.326192502001139,0.543,13.6443297
+50.0,1.263075059750477,0.556,1.337822339295826,0.5275,13.6694539
+51.0,1.2560654378465812,0.5575,1.3398909574446176,0.522,13.4980698
+52.0,1.2389522192066347,0.557375,1.3340422040960849,0.5285,13.6909085
+53.0,1.246353421302485,0.556875,1.3499636260855394,0.5225,13.8806309
+54.0,1.239381110228978,0.558375,1.3406075810189342,0.534,13.8525488
+55.0,1.2433353093378448,0.55425,1.324629644870911,0.533,14.0841106
+56.0,1.2354395626741617,0.5565,1.3356743926443475,0.5335,13.8873882
+57.0,1.237418848254395,0.556125,1.3457505939544188,0.5195,13.8577057
+58.0,1.2290688215551495,0.564125,1.3193828541603463,0.529,13.9479669
+59.0,1.2205249908656897,0.5705,1.3362343110804618,0.5295,14.0356272
+60.0,1.2150364051581675,0.567875,1.3377327253949152,0.5175,13.9742641
+61.0,1.2042945810922459,0.567625,1.299347369664342,0.545,13.8784674
+62.0,1.1869554422683357,0.57375,1.295421337121282,0.541,13.7720781
+63.0,1.1913576149956475,0.579625,1.2847922968229424,0.552,14.0236965
+64.0,1.1814797193753155,0.57875,1.2925302533151977,0.5485,14.1982342
+65.0,1.1852575527301905,0.575875,1.2974096833767914,0.5445,14.0822313
+66.0,1.175954399715992,0.58,1.2954700090752658,0.5405,14.1029847
+67.0,1.1698802600032,0.585375,1.2873640487297948,0.5515,14.2222606
+68.0,1.1747750187406745,0.582125,1.2933753825100305,0.5495,14.0698178
+69.0,1.176758844846846,0.5765,1.2942414059631298,0.5475,14.049275
+70.0,1.1626001479337986,0.5805,1.291382934296348,0.5445,13.9798672
+71.0,1.1736646404840752,0.580875,1.2930450557210065,0.548,13.9478874
+72.0,1.1694081129701102,0.58175,1.2878783185602518,0.5455,14.143925
+73.0,1.1612580167200328,0.588875,1.2915025684304995,0.5475,14.0607609
+74.0,1.1554162234151095,0.585375,1.2825781984163054,0.549,14.2038661
+75.0,1.1532475297506493,0.585125,1.2931856305636016,0.5425,14.0194029
+76.0,1.1451593904238064,0.58775,1.2845532911864248,0.547,14.1575925
+77.0,1.1492909645909664,0.590625,1.2822127225089912,0.5465,14.0781696
+78.0,1.1492410836647744,0.59025,1.2798070597934794,0.5585,14.098592
+79.0,1.1545649146597519,0.58975,1.2839808783679567,0.5435,14.258488
+80.0,1.158975975929335,0.583625,1.292040375460197,0.5425,14.1885269
+81.0,1.141626165293428,0.59075,1.2716967459370532,0.55,14.2664008
+82.0,1.1253915069740432,0.59625,1.268181103739951,0.5505,14.3080074
+83.0,1.1285409318245216,0.591375,1.2698792482003705,0.551,14.16291
+84.0,1.1300053654492035,0.596125,1.2668427781471037,0.5535,14.3088668
+85.0,1.1255487032127391,0.600875,1.2665418062110707,0.558,14.2209616
+86.0,1.1377536583624235,0.591875,1.2665377357948204,0.5515,14.274974
+87.0,1.1252373801657416,0.5945,1.266072192143839,0.556,14.2361695
+88.0,1.1241915207941389,0.600625,1.2632048327671943,0.5525,14.2223963
+89.0,1.1228873853680117,0.600625,1.2666055963428553,0.552,14.4269076
+90.0,1.12557193856232,0.597625,1.2659554953031278,0.5515,14.3096142
+91.0,1.1172935662456493,0.6025,1.2721618178688976,0.5495,14.3176152
+92.0,1.118908031135265,0.606,1.2617799352496106,0.552,14.4369106
+93.0,1.119172639667468,0.6045,1.2685502610502812,0.5525,14.4291215
+94.0,1.1140036235135053,0.595625,1.2708219571047736,0.549,14.4566621
+95.0,1.118114251449247,0.600875,1.2645198575680199,0.5505,14.36721
+96.0,1.1221460595068176,0.59725,1.2678244836707697,0.5495,14.4190264
+97.0,1.1222327217316366,0.59725,1.264538032676506,0.5485,14.5194129
+98.0,1.1040915771649886,0.603375,1.2646420254370487,0.557,14.3773226
+99.0,1.1141455596158494,0.596125,1.2617442374133452,0.56,14.4428252
+100.0,1.116353212625066,0.596,1.2637919340908566,0.555,14.4109249
+101.0,1.1103282711157212,0.598625,1.2565343531672128,0.555,14.4365171
+102.0,1.101760974151141,0.602375,1.25923103878668,0.5535,14.476484
+103.0,1.1082838564073645,0.609875,1.2557994847598184,0.5575,14.5165641
+104.0,1.095031309559261,0.609125,1.2564420719858131,0.555,14.408565
+105.0,1.1002173548553162,0.608875,1.252878045094207,0.5605,14.5044739
+106.0,1.0959186074473726,0.61175,1.2532443976780008,0.554,14.6739368
+107.0,1.0990968495728408,0.602375,1.2547726212028347,0.557,14.6413638
+108.0,1.100968336416274,0.609125,1.253793622485958,0.556,14.5580032
+109.0,1.104766573974422,0.6055,1.2557147325798013,0.5545,14.3310999
+110.0,1.104298360743708,0.6075,1.2514087572682986,0.5565,14.4743644
+111.0,1.1063132614827664,0.605875,1.2537732481112982,0.5595,14.4957046
+112.0,1.1063622860749882,0.6045,1.2533806762968076,0.563,14.6431728
+113.0,1.0958888767678567,0.6035,1.2514053135780332,0.557,14.5591325
+114.0,1.1047888519916138,0.6045,1.2513394508878948,0.566,14.5222175
+115.0,1.0943723965297103,0.603,1.2501149491408061,0.56,14.5046575
+116.0,1.1024252537737045,0.60725,1.2544432274720891,0.558,14.5665028
+117.0,1.1019628812334505,0.604875,1.2495313138259807,0.5655,14.4860322
+118.0,1.0951464076701953,0.609625,1.2541648314998317,0.556,14.5191755
+119.0,1.1006300797007322,0.604875,1.2488222470103332,0.5655,14.5660115
+120.0,1.0861879580925962,0.619375,1.2528937514034104,0.5625,14.5908326
+121.0,1.082199018836983,0.613,1.2486644077870812,0.5635,14.4475893
+122.0,1.0938108249841794,0.6095,1.250240468545784,0.5635,14.4728122
+123.0,1.0926590815438308,0.608,1.2470787121981195,0.566,14.624248
+124.0,1.096732621127835,0.608,1.247561125875503,0.565,14.4535908
+125.0,1.1014265553202576,0.60175,1.2451149714164285,0.565,14.548036
+126.0,1.0947156040917423,0.61025,1.2449236442320595,0.5615,14.3996691
+127.0,1.0937438842578266,0.614125,1.2469064344942629,0.565,14.5767773
+128.0,1.079807320566041,0.616875,1.2471043685871859,0.5635,14.652292
+129.0,1.088313007025598,0.61225,1.2461083146488918,0.567,14.4000634
+130.0,1.0848612113364913,0.613375,1.248365278391203,0.5655,14.6998804
+131.0,1.078484783525951,0.615625,1.2454441374933374,0.563,14.7103772
+132.0,1.0783425338304478,0.61325,1.2465316875301682,0.5645,14.6719551
+133.0,1.0869827001337526,0.612125,1.245269172028706,0.5645,14.5390599
+134.0,1.0897246976002282,0.608,1.2467369075941273,0.5575,14.5948143
+135.0,1.0917709960513455,0.603375,1.247644585056021,0.5605,14.5812494
+136.0,1.0879209751856984,0.60725,1.2446197265404972,0.564,14.5561679
+137.0,1.0833220539120074,0.614,1.246359121818303,0.5635,14.5960763
+138.0,1.0727954748691557,0.6185,1.247490147160208,0.5645,14.4926432
+139.0,1.0873991669797005,0.61575,1.2458239587314954,0.5625,14.5005445
+140.0,1.089090211929346,0.61825,1.2458630743589587,0.5625,14.5743146
+141.0,1.0851214902852133,0.618,1.2432538615136424,0.5615,14.5850047
+142.0,1.0811520207431558,0.6215,1.2438817396114263,0.5655,14.6543626
+143.0,1.0772488463140537,0.622375,1.2432059596635283,0.568,14.7068158
+144.0,1.0860889986543312,0.618375,1.2425303322244667,0.563,14.5460072
+145.0,1.082262305634113,0.606625,1.2440479409345793,0.5645,14.6510187
+146.0,1.0773957535473477,0.618875,1.2444595692017162,0.5645,14.6522808
+147.0,1.0856322327284924,0.61525,1.2426483170137028,0.567,14.5760833
+148.0,1.0744046564305696,0.61775,1.2418929836020334,0.565,14.7908474
+149.0,1.0880204422819775,0.609,1.242165650995874,0.5685,14.6450553
+150.0,1.079424235859795,0.613625,1.2423859522173017,0.567,14.6120258
+151.0,1.0754070167286696,0.61275,1.244135044027801,0.5655,14.7034579
+152.0,1.075395018243674,0.6125,1.2429775308290782,0.563,14.5182634
+153.0,1.0734326470902569,0.617125,1.241185051627586,0.5675,14.5124191
+154.0,1.0800490935130316,0.611875,1.2406918921123289,0.566,14.7105367
+155.0,1.0812611398541314,0.618125,1.2421258512253415,0.5645,14.6467188
+156.0,1.0669635728217643,0.618625,1.2415266592008316,0.564,14.577965
+157.0,1.080646794399443,0.61825,1.2420682789030681,0.562,14.7238379
+158.0,1.0880726836878365,0.61725,1.241531721048019,0.567,14.6196427
+159.0,1.0869481752032835,0.616875,1.2415479369822755,0.566,14.4735731
+160.0,1.0756775102272742,0.616375,1.2437069314500606,0.563,14.6270309
+161.0,1.0815435558791733,0.61275,1.2424995906965244,0.5655,14.6042192
+162.0,1.0767528439959069,0.613375,1.241103633416577,0.566,14.5911533
+163.0,1.0831821522442142,0.61525,1.2412252988949473,0.5665,14.6275043
+164.0,1.070576114536538,0.619875,1.2419648926163347,0.566,14.5599641
+165.0,1.090427717286562,0.6095,1.2423699857076484,0.5635,14.5238431
+166.0,1.0630191783580398,0.622125,1.2417300195182925,0.5655,14.5532187
+167.0,1.0708994502811264,0.621875,1.2415790631552621,0.566,14.630444
+168.0,1.067926634220364,0.615,1.2411362538794133,0.5645,14.5589019
+169.0,1.076751084204367,0.61125,1.2412362955613994,0.5665,14.4660675
+170.0,1.070472696770259,0.617,1.2409165979944063,0.567,14.6726661
+171.0,1.0663337222711078,0.618,1.2404039374012783,0.5665,14.6087353
+172.0,1.0725234608638152,0.613625,1.2406567880208028,0.5685,14.6677537
+173.0,1.072992828493098,0.61375,1.242216803186321,0.5675,14.5406408
+174.0,1.0646183318080127,0.623875,1.2412921475359262,0.567,14.539297
+175.0,1.0814626946566752,0.6095,1.2412550627748837,0.5665,14.6157996
+176.0,1.0637959638003647,0.620875,1.240254552962168,0.569,15.2426552
+177.0,1.0775124273546934,0.615,1.2404323890955922,0.568,15.0623497
+178.0,1.0684771109233027,0.62125,1.2408057584058674,0.5695,14.4473813
+179.0,1.064997007670873,0.618875,1.2409065602477318,0.568,14.9252663
+180.0,1.0853188818644275,0.615375,1.241756442412931,0.5645,15.0553087
+181.0,1.0723787152426756,0.609875,1.2409910274926084,0.568,14.4357932
+182.0,1.0798211182304935,0.612625,1.241649187658252,0.566,14.6326167
+183.0,1.0680217992743604,0.620625,1.2408709208176558,0.566,14.5286158
+184.0,1.082317621315392,0.60525,1.2408365046588363,0.566,14.524018
+185.0,1.0678221510505235,0.619875,1.2408972477033255,0.5665,14.6014516
+186.0,1.0628243052131188,0.61625,1.2406602877086075,0.5685,14.6812657
+187.0,1.0617546604520998,0.622625,1.241407661791022,0.5665,14.3843408
+188.0,1.0793570370848462,0.616875,1.2413150660837053,0.5665,14.5970121
+189.0,1.0787423326952976,0.6145,1.2413674900288463,0.566,14.4857065
+190.0,1.0701771971409562,0.617625,1.2407163330746391,0.567,14.5206026
+191.0,1.0701759072087569,0.620875,1.2410263769543541,0.568,14.5850941
+192.0,1.0685708532616058,0.616125,1.2404926656260966,0.5675,14.5744162
+193.0,1.0729520967209174,0.614625,1.2413250883482927,0.568,14.3926992
+194.0,1.07520337154751,0.6185,1.2410090812129266,0.5675,14.6188892
+195.0,1.084254279952915,0.61475,1.241072433446629,0.565,14.536415
+196.0,1.0885902416633608,0.614375,1.2406006627329147,0.568,14.4046883
+197.0,1.0884391833167122,0.613125,1.2402557916683326,0.5675,14.5091527
+198.0,1.0773994190307936,0.616625,1.2395882833528789,0.567,14.4972993
+199.0,1.0705480166366623,0.626875,1.240187015169324,0.567,14.5703108
+200.0,1.0801774570061202,0.60925,1.2397648166117428,0.568,14.3953674
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_cifar.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_cifar.csv.mtd
new file mode 100644
index 00000000000..3a7c02770e2
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_cifar.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 200,
+    "cols": 6,
+    "nnz": 1200,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-15 20:25:08 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_mnist.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_mnist.csv
new file mode 100644
index 00000000000..8ff273d80e6
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_mnist.csv
@@ -0,0 +1,30 @@
+1.0,1.1093782488379267,0.6687440476190476,0.7103196227035953,0.751,9.6345167
+2.0,0.5368217115382201,0.843125,0.5409422028335673,0.828,9.4952644
+3.0,0.43075663750726945,0.877,0.4614419577545038,0.855,9.5848966
+4.0,0.3712808445441949,0.89175,0.4083165263014015,0.864,9.5296959
+5.0,0.3313409749491643,0.905,0.36918884861362433,0.872,9.5549979
+6.0,0.3002519872908724,0.911875,0.3374946657663495,0.885,9.5610894
+7.0,0.2738142399887154,0.920625,0.3109021641498068,0.895,9.5647321
+8.0,0.2509429560107622,0.925875,0.28847201710915077,0.903,9.5164089
+9.0,0.23139162590379547,0.930875,0.2684646808503931,0.91,9.5464474
+10.0,0.21415825658663898,0.93525,0.2511333972251902,0.917,9.5202213
+11.0,0.1991027077413793,0.941,0.23575085063304155,0.921,9.5216028
+12.0,0.18567423792810084,0.9455,0.2219718849159556,0.923,9.5566332
+13.0,0.1735862084531195,0.949125,0.20955243879443033,0.926,9.5633677
+14.0,0.16300291268695882,0.95325,0.19891562427291376,0.931,9.6062662
+15.0,0.1537152427254511,0.956,0.19013516779236428,0.939,9.5037059
+16.0,0.14563275824032784,0.95825,0.18214669966884453,0.941,9.5329045
+17.0,0.13842570188433764,0.96025,0.17513901088180947,0.942,9.5138919
+18.0,0.13215219941696327,0.96225,0.1688552742284023,0.945,9.5152434
+19.0,0.12658806589066232,0.963,0.16313021149214327,0.949,9.515968
+20.0,0.12165114480421958,0.964375,0.15806127305317655,0.95,9.5011049
+21.0,0.11704335397099742,0.965625,0.15344154539468688,0.951,9.518604
+22.0,0.11285122230399844,0.9665,0.149181600488355,0.951,9.4965887
+23.0,0.10899167826483962,0.96725,0.14518200962060449,0.952,9.5114517
+24.0,0.10548009999768435,0.968,0.14179011384435702,0.953,9.5125976
+25.0,0.1022286248726787,0.96875,0.13853975328464868,0.953,9.5550386
+26.0,0.09907791719622959,0.969625,0.13584454806628404,0.953,9.522025
+27.0,0.09628575529384678,0.970375,0.13329325995653465,0.953,9.488768
+28.0,0.09366223292106875,0.97125,0.13087012733336528,0.955,9.4671204
+29.0,0.09115698302004199,0.972375,0.12865843448826594,0.955,9.4716141
+30.0,0.08878593398336924,0.973375,0.12666496497283158,0.956,9.4608253
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_mnist.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_mnist.csv.mtd
new file mode 100644
index 00000000000..4a8ff0709ea
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_sgd_mnist.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 30,
+    "cols": 6,
+    "nnz": 180,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 08:39:42 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_cifar.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_cifar.csv
new file mode 100644
index 00000000000..c217211340c
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_cifar.csv
@@ -0,0 +1,200 @@
+1.0,2.4819501383599136,0.15825,2.1954280358236584,0.167,12.8226832
+2.0,2.1241497498005764,0.213375,1.9943102329399705,0.2875,12.1007488
+3.0,2.027234758289565,0.25675,1.9223933955898993,0.3205,12.3715178
+4.0,1.9741069605932597,0.274625,1.8224082775974753,0.3625,12.2885312
+5.0,1.912629416464321,0.304125,1.8267242916044975,0.3615,12.6480058
+6.0,1.8545270385656474,0.321375,1.7750925026497926,0.378,16.8090214
+7.0,1.8061631085734955,0.34125,1.700838363120779,0.4035,15.5016037
+8.0,1.7693214725643436,0.35275,1.7018485209067384,0.4,16.7452067
+9.0,1.7241363388625457,0.373875,1.6192016730845822,0.422,16.5303905
+10.0,1.6899718721904458,0.39,1.6034191754305727,0.426,16.5115838
+11.0,1.6524994895007465,0.400875,1.5550641945093,0.4435,14.728634
+12.0,1.6432949550882703,0.402375,1.592158699447699,0.434,16.4731352
+13.0,1.615988515361932,0.416875,1.5275186061075552,0.444,16.2860829
+14.0,1.587172073437394,0.421375,1.542636861146399,0.448,14.7210643
+15.0,1.5805272496783462,0.42575,1.5374200491552987,0.452,16.7437395
+16.0,1.5593052649069628,0.438875,1.4906890664716714,0.4635,16.2719542
+17.0,1.5453559342199386,0.444625,1.4993367717382116,0.461,14.5490643
+18.0,1.5369730980893246,0.443375,1.4733669840365786,0.472,16.4685827
+19.0,1.5329202114576437,0.445625,1.4656331216303011,0.472,16.026961
+20.0,1.5168256117903975,0.4475,1.4588440051597782,0.4695,14.3425992
+21.0,1.4907908259125837,0.457625,1.4422171631303455,0.4795,16.1882807
+22.0,1.476924210077713,0.4655,1.4341120698340857,0.4865,16.1500595
+23.0,1.4769900900189454,0.459375,1.429810053369566,0.4805,14.4395052
+24.0,1.4708689301486537,0.4675,1.4263997067910832,0.486,16.1312856
+25.0,1.4664390243418846,0.469375,1.4196162445211573,0.488,16.1682291
+26.0,1.4500711358908482,0.475,1.4233573098550596,0.4895,14.7780006
+27.0,1.4566358269076984,0.477,1.4169126726313708,0.491,16.3483808
+28.0,1.45020194579957,0.477,1.4015731293983666,0.499,16.2112962
+29.0,1.4495154030298312,0.470625,1.4092490077440627,0.497,14.2588481
+30.0,1.4277077090496262,0.478125,1.4073540252988443,0.496,15.9825039
+31.0,1.4257526659390147,0.483125,1.3912525839448655,0.4955,14.3548938
+32.0,1.4216543769112138,0.48925,1.3996579075917825,0.5005,16.2397246
+33.0,1.4156253075995042,0.49,1.3875123274421899,0.5045,16.6935173
+34.0,1.4249010004159126,0.492375,1.3812148909447315,0.5075,14.7783196
+35.0,1.4112813093990046,0.49625,1.384796418865822,0.504,16.5775371
+36.0,1.414855017245599,0.487,1.3778313279262495,0.5045,14.7421714
+37.0,1.4033908692844592,0.493625,1.3757381449125663,0.5055,16.5465819
+38.0,1.3889955346521285,0.50025,1.3766958318634974,0.509,14.7834195
+39.0,1.3928926643768778,0.49725,1.364270417033822,0.5095,16.7807185
+40.0,1.3889738758794328,0.498125,1.3722521031061374,0.508,14.8672155
+41.0,1.3803343802898287,0.501625,1.3536640488693,0.5175,16.7133591
+42.0,1.3642775420059539,0.5085,1.3519250819576982,0.519,14.7586796
+43.0,1.3739900485987695,0.508125,1.3543994320606951,0.524,16.4919478
+44.0,1.3628192628252611,0.514875,1.35345752834436,0.5195,14.8291684
+45.0,1.360944316101872,0.50375,1.3528284014595926,0.526,17.5073369
+46.0,1.355830000203948,0.5125,1.3467699615240458,0.5265,14.7639548
+47.0,1.3590905769575823,0.513875,1.3513241236471443,0.524,16.3159131
+48.0,1.3639192146204642,0.5145,1.348791900737384,0.523,14.6808939
+49.0,1.3549894740183361,0.51375,1.3461225392077345,0.5285,16.5167279
+50.0,1.3559619989176233,0.513375,1.3431456116296363,0.528,14.9592641
+51.0,1.3523482718050015,0.510375,1.3414689637160735,0.5305,16.6538917
+52.0,1.3471776561874822,0.517375,1.34041669554498,0.5315,14.8952145
+53.0,1.3528346195106322,0.51775,1.342116052772083,0.5245,16.6871542
+54.0,1.3473656938129235,0.51425,1.3377828232469857,0.529,14.9586728
+55.0,1.343422890566923,0.525625,1.3430565980062648,0.5265,16.7949393
+56.0,1.3385820768375822,0.5205,1.3418470692339022,0.5315,15.4616934
+57.0,1.3499835756962406,0.523,1.3376766313861896,0.528,16.9351981
+58.0,1.3419496787287863,0.52675,1.3364162591383668,0.5285,15.1126551
+59.0,1.347486244594015,0.5195,1.3326480998741057,0.5275,17.0143573
+60.0,1.3409485500955667,0.523375,1.3278794575807427,0.5345,15.2219919
+61.0,1.328747869292858,0.526625,1.3236297821012102,0.5295,16.8531891
+62.0,1.3290481474889593,0.525625,1.32219772373381,0.535,14.331144
+63.0,1.3383523911819009,0.523375,1.3244315875906025,0.531,15.9338209
+64.0,1.3261881691408421,0.52475,1.3241596952722798,0.5355,14.4321958
+65.0,1.3314473157528333,0.52575,1.323290018072758,0.534,16.0115732
+66.0,1.3342640798581729,0.523875,1.3222906004178772,0.536,14.3971749
+67.0,1.318069990031956,0.527375,1.3213082859971381,0.532,16.0045866
+68.0,1.320171850991,0.523375,1.3193062634330792,0.539,14.4096936
+69.0,1.32040753060354,0.52775,1.3190576438358175,0.536,15.978542
+70.0,1.3230322936637195,0.523875,1.3251188663297733,0.5315,14.3797398
+71.0,1.3244611489160294,0.52675,1.323866503310526,0.532,15.933473
+72.0,1.3192050760889664,0.529625,1.31863668913747,0.5375,14.3648268
+73.0,1.3214572972219094,0.525625,1.319369511104412,0.536,16.0130725
+74.0,1.3304650689032511,0.5205,1.321135326103876,0.5375,14.3691027
+75.0,1.324742654835387,0.521375,1.3202410408451828,0.534,15.978979
+76.0,1.3185606656341573,0.527625,1.3168221131248072,0.5385,14.4541098
+77.0,1.3127525376174825,0.52975,1.3189589743198078,0.532,16.0679238
+78.0,1.3214510321983362,0.52675,1.3154555274324895,0.5345,14.3882586
+79.0,1.3138102020454596,0.529,1.3173555308230183,0.536,16.0367658
+80.0,1.3160156963356038,0.522875,1.3179678807845718,0.5365,14.4267574
+81.0,1.3185894931850917,0.52675,1.3167544116005843,0.533,15.9544915
+82.0,1.3155511214607427,0.533625,1.3142872937877783,0.535,14.4621926
+83.0,1.3191591312523032,0.52675,1.3139279783295512,0.536,16.0198675
+84.0,1.3047383733486067,0.535125,1.3140554074649027,0.536,14.5224685
+85.0,1.2998807810293591,0.53925,1.3130442287198176,0.538,16.043861
+86.0,1.3048678372577696,0.536,1.3147052667201322,0.536,14.390018
+87.0,1.3156347708054161,0.523375,1.3137179075564476,0.535,15.9995276
+88.0,1.3078233375372548,0.527,1.31269936051695,0.5375,14.7599212
+89.0,1.301694427789555,0.534125,1.3130564091965442,0.535,16.076435
+90.0,1.307213498766632,0.52875,1.312260783377263,0.5325,14.4012776
+91.0,1.3223504815722316,0.5205,1.315197929625652,0.5345,16.0667042
+92.0,1.3121390053008224,0.53275,1.3124919606563745,0.5365,14.4533982
+93.0,1.3148184122871722,0.524625,1.311203033094174,0.5365,16.0702091
+94.0,1.3099455881211106,0.53375,1.3114774517235614,0.5375,14.513704
+95.0,1.3083614915540493,0.537375,1.3109332237160636,0.5375,16.1220703
+96.0,1.3127841293948619,0.528625,1.311932246429838,0.535,14.5003375
+97.0,1.30615867288354,0.530125,1.3096348769315331,0.5365,16.1178876
+98.0,1.301983678563513,0.52825,1.3110851848482254,0.538,14.5334463
+99.0,1.3075021120364343,0.533,1.3123567103595142,0.5365,16.028136
+100.0,1.3051529903938057,0.53425,1.3113587479868671,0.5365,14.5149701
+101.0,1.3024572853872496,0.53275,1.3105569316681898,0.5385,16.1332018
+102.0,1.3008109813519082,0.532,1.3101455864351546,0.5375,14.5657176
+103.0,1.3042768028249934,0.534,1.310465448697579,0.538,16.0753667
+104.0,1.3079622199290803,0.5305,1.3103760940648996,0.5385,14.5056954
+105.0,1.3142336712954228,0.53175,1.3101902095281655,0.5365,16.12271
+106.0,1.3040488430081085,0.5315,1.3103340759717863,0.537,14.5204028
+107.0,1.2993828995467607,0.536,1.3095603939991503,0.5385,16.1341865
+108.0,1.310235843448544,0.529,1.3091904795554128,0.538,14.5112841
+109.0,1.3079399158195157,0.53175,1.3105620002262224,0.539,16.1035164
+110.0,1.308903113318373,0.532875,1.3094641162925613,0.5365,14.5168897
+111.0,1.3033192566386995,0.53375,1.3104795043640327,0.5355,16.1450482
+112.0,1.2951055070115582,0.53325,1.309137470344777,0.5375,14.5270356
+113.0,1.3128955647252174,0.534,1.309990891187841,0.5375,16.1122688
+114.0,1.3021592435466052,0.539375,1.3100196319551212,0.538,14.5811335
+115.0,1.2973206779494846,0.539,1.3104281344138415,0.537,16.1094314
+116.0,1.308543129843251,0.528625,1.30930458919886,0.5375,14.4627417
+117.0,1.2991942470529403,0.5365,1.3085857059080888,0.5375,16.1090825
+118.0,1.2974294267193025,0.53275,1.3086480164427328,0.5385,14.5340735
+119.0,1.2933060365526183,0.539,1.3089961375123735,0.541,16.1258455
+120.0,1.310340502853172,0.527,1.308474706660275,0.5395,14.4783545
+121.0,1.2983906828092213,0.542875,1.3086250639738533,0.54,16.0524143
+122.0,1.2939351291021872,0.534,1.308440324228956,0.5395,14.4535
+123.0,1.2992417093989803,0.541875,1.3079537480569292,0.54,16.0264719
+124.0,1.3028391427293256,0.53875,1.30803101993412,0.54,14.4733958
+125.0,1.3048058914734078,0.53575,1.308175552624005,0.5395,16.1102956
+126.0,1.3132636670158506,0.529375,1.3082581947755898,0.5395,14.478416
+127.0,1.3000461195666042,0.536375,1.3076722796662075,0.539,16.1097683
+128.0,1.3080240859034113,0.5295,1.3079367699114441,0.5385,14.5393235
+129.0,1.2998889882289268,0.532375,1.3078430159961798,0.5385,16.1174312
+130.0,1.3044408971687862,0.537875,1.3074568056484965,0.539,14.485833
+131.0,1.3000980131813082,0.531625,1.307951354348347,0.537,16.0500766
+132.0,1.2944470477122374,0.5365,1.307494635320011,0.5385,14.4679617
+133.0,1.2982900974688767,0.5335,1.3073653260620877,0.539,16.0490205
+134.0,1.3071031687429646,0.533,1.3074821609033018,0.539,14.5065979
+135.0,1.2986052689698258,0.534625,1.3075836761219246,0.538,16.066862
+136.0,1.2895029802358513,0.53525,1.3073350204017655,0.5395,14.5415509
+137.0,1.3000299778369215,0.531875,1.3078150288686006,0.539,16.1089647
+138.0,1.2911167369073444,0.537,1.3076130956444139,0.5395,14.5078313
+139.0,1.29036220769725,0.538625,1.30745664033635,0.538,16.134817
+140.0,1.298080872631335,0.5345,1.3073407141230322,0.5365,14.4369267
+141.0,1.3025891068319724,0.5355,1.3070792055271505,0.538,16.1028676
+142.0,1.2946045135934998,0.533375,1.3069526080745955,0.539,14.5663422
+143.0,1.3032015927455312,0.53325,1.3069122280168874,0.5385,16.1128809
+144.0,1.2995359340671837,0.5415,1.3067171192769849,0.5385,14.4924564
+145.0,1.3023605426524023,0.53425,1.3068084984899109,0.5395,16.0955384
+146.0,1.30930319485174,0.536,1.3070832146909857,0.5395,14.4667475
+147.0,1.2996770951326868,0.5385,1.3071774507007867,0.539,16.1178473
+148.0,1.2967788143087216,0.535,1.307244866162839,0.5395,14.5053554
+149.0,1.3040574953036825,0.533625,1.307385435625991,0.5385,16.0416278
+150.0,1.3015946061192016,0.54475,1.307144346584109,0.5385,14.3857148
+151.0,1.30008500298661,0.533625,1.3070401943057945,0.539,16.0516319
+152.0,1.3060004570482606,0.5315,1.3069878428640846,0.538,14.5040651
+153.0,1.3039147393882513,0.53625,1.3070751575819681,0.538,16.0710873
+154.0,1.2924859620290725,0.539125,1.3071099345998627,0.538,14.4066711
+155.0,1.305181622210978,0.533125,1.3070866668531675,0.539,16.1578756
+156.0,1.3067503725773457,0.532625,1.3072734547354332,0.539,14.4561437
+157.0,1.2974722388735458,0.53975,1.3070760574570204,0.538,16.0989079
+158.0,1.3000584607790142,0.538375,1.3071830952087906,0.539,14.454967
+159.0,1.3081136534291358,0.535375,1.3073356682555537,0.537,16.0018707
+160.0,1.3004744555150258,0.5365,1.3075186996179962,0.537,14.4905311
+161.0,1.296476702807453,0.537625,1.307368689732197,0.5375,16.1077928
+162.0,1.288406756203036,0.532625,1.3072671787650494,0.5375,14.480456
+163.0,1.2946820262839696,0.544625,1.3072713570618757,0.538,16.1547589
+164.0,1.2959582712618745,0.53575,1.3072286637496255,0.5375,14.4900589
+165.0,1.2977611865811967,0.53625,1.3071565196116044,0.537,16.0829189
+166.0,1.3025448788009075,0.53575,1.3071775760998985,0.5365,14.4592435
+167.0,1.2959205015102966,0.5375,1.3070067177984517,0.538,16.040717
+168.0,1.2980978607835076,0.5375,1.3069131168819554,0.538,14.4669075
+169.0,1.316576715578295,0.5295,1.3068651614368016,0.538,16.0375268
+170.0,1.3022452358627001,0.5375,1.3069451965283987,0.538,14.4853237
+171.0,1.3067203198134225,0.53025,1.3068472905654809,0.538,16.0196374
+172.0,1.305151142210352,0.5335,1.3067921163070488,0.5385,14.5103778
+173.0,1.2989866165691726,0.537,1.306790403551562,0.538,16.0988433
+174.0,1.298991254023191,0.534875,1.3067496217039258,0.539,14.4617208
+175.0,1.2937396861643513,0.538,1.306611274851869,0.5385,16.0309367
+176.0,1.2957440792415318,0.534125,1.3066816926504232,0.538,14.4353061
+177.0,1.309066530764555,0.53475,1.3067317608546547,0.5385,16.0850414
+178.0,1.3009487254270833,0.540875,1.3068657712647895,0.538,14.4822867
+179.0,1.295012935326623,0.535625,1.306792522837967,0.538,16.0867644
+180.0,1.3037339178736633,0.53175,1.306696087482113,0.5385,14.491736
+181.0,1.2943573305000133,0.533375,1.306673840375351,0.538,16.0164477
+182.0,1.2936152920134325,0.53875,1.3066134419092958,0.538,14.4022612
+183.0,1.299497084220198,0.541625,1.3066728376864818,0.538,16.0295703
+184.0,1.297338283400904,0.538375,1.3066281454172877,0.5385,14.4810659
+185.0,1.2967509932832386,0.539,1.3066241777176386,0.538,16.0484665
+186.0,1.294193241217018,0.536125,1.306547977835477,0.538,14.4407416
+187.0,1.2991440110083268,0.537125,1.3064796629738546,0.538,16.0741345
+188.0,1.2896026478083573,0.539625,1.3064580423010745,0.5375,14.4357631
+189.0,1.290681102689735,0.531,1.3064867313617383,0.538,16.0705034
+190.0,1.2949458246371983,0.534875,1.3064980174098149,0.538,14.4747998
+191.0,1.291540949525548,0.540125,1.3064895945898964,0.5375,16.0863125
+192.0,1.3087596771411594,0.535,1.3065278044087034,0.5375,14.4270826
+193.0,1.3013773823416332,0.538,1.30655243230613,0.5375,16.0726028
+194.0,1.308975174937881,0.530625,1.3066240567819654,0.5375,14.4525801
+195.0,1.290120110540905,0.531375,1.3066275362979325,0.5375,16.1019442
+196.0,1.3034732654407712,0.529625,1.3066082069241098,0.538,14.4948722
+197.0,1.298069268643873,0.52975,1.3065282004296128,0.538,16.0948817
+198.0,1.2986606845041118,0.538625,1.3064902892378498,0.538,14.4480757
+199.0,1.2997682128209003,0.534,1.3064696007392274,0.5375,16.106717
+200.0,1.2974830155945531,0.539125,1.3065108650287482,0.5375,14.4931709
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_cifar.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_cifar.csv.mtd
new file mode 100644
index 00000000000..6c7901fec6a
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_cifar.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 200,
+    "cols": 6,
+    "nnz": 1200,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-15 13:44:27 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_cifar.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_cifar.csv
new file mode 100644
index 00000000000..f49b7fbd598
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_cifar.csv
@@ -0,0 +1,200 @@
+1.0,2.376452688553843,0.155625,2.1556098635877037,0.2105,13.4727061
+2.0,2.134208736195225,0.208875,2.105177277710116,0.229,11.6442175
+3.0,2.032875826117593,0.24475,1.8898348708091248,0.3315,11.6353514
+4.0,1.9427902968640334,0.292375,1.8092403314441945,0.359,11.9605232
+5.0,1.856056191458096,0.324625,1.7704868669153397,0.3715,11.611253
+6.0,1.8048423057854228,0.353375,1.652339981973803,0.4015,11.2635212
+7.0,1.7613481474084223,0.35875,1.6715358315985873,0.408,11.273542
+8.0,1.7228280048356475,0.371125,1.6169342452755069,0.42,11.4165315
+9.0,1.7042061744805554,0.388,1.5880115035153421,0.426,12.3753668
+10.0,1.680296495493985,0.396125,1.5782422838320826,0.432,11.0482037
+11.0,1.660500844945354,0.406125,1.5820302969326532,0.421,11.1458407
+12.0,1.6479928843932672,0.40575,1.5645482394247503,0.431,11.1351257
+13.0,1.6233078717461356,0.409875,1.5367497116087747,0.442,10.6328212
+14.0,1.597831925202846,0.4195,1.5335680584488711,0.438,11.8666012
+15.0,1.5934214818483465,0.4285,1.529172479851137,0.437,11.5239298
+16.0,1.5839027109797763,0.4355,1.5568644147771329,0.446,12.049156
+17.0,1.5774055638466864,0.43475,1.5020714556222852,0.4505,10.987726
+18.0,1.5515425441190742,0.439,1.48392225157081,0.4685,10.3778375
+19.0,1.5416895791337815,0.444625,1.4792698340722745,0.4605,10.2841794
+20.0,1.5246316885980944,0.448625,1.4713636544811939,0.469,10.2279888
+21.0,1.477323835998623,0.46575,1.4426045184144858,0.4755,10.3257379
+22.0,1.4854151915336127,0.46225,1.4425894368257444,0.479,10.4624141
+23.0,1.4898645139538458,0.462875,1.4500906797364026,0.476,10.7450699
+24.0,1.4711832451689022,0.473125,1.4419756348619515,0.4775,10.9177052
+25.0,1.4701707509959818,0.470375,1.4331732642784207,0.485,10.2696629
+26.0,1.4645130350349913,0.473375,1.4242761343785173,0.489,10.4850996
+27.0,1.4467853446065027,0.478625,1.4190420704491633,0.4895,10.5481403
+28.0,1.4534114658439001,0.4815,1.4248702929585566,0.4895,10.324821
+29.0,1.4364611534539131,0.487,1.4123989189549304,0.488,10.4669579
+30.0,1.446309763375203,0.481875,1.4137452926107268,0.489,10.5837967
+31.0,1.4416450673203447,0.48275,1.4107818299135848,0.4935,10.2361735
+32.0,1.431987844290674,0.483625,1.4049492177597962,0.498,10.3169358
+33.0,1.4255560789782302,0.485125,1.4056418610839123,0.492,10.362491
+34.0,1.4298778306450786,0.48575,1.411402290408623,0.4975,10.3743304
+35.0,1.4072003121356107,0.498625,1.3938863035583569,0.4875,10.5676677
+36.0,1.4170384008599304,0.49175,1.3979400645447513,0.504,10.5253142
+37.0,1.4274224064539414,0.487375,1.4002178731652006,0.494,10.3967215
+38.0,1.4057407637754045,0.494875,1.3877039802067248,0.507,10.4744136
+39.0,1.3925094494918993,0.506125,1.3887825075492275,0.5005,10.5590477
+40.0,1.4035896871987326,0.492625,1.3832010003109698,0.502,10.4390597
+41.0,1.3824016424340198,0.5095,1.3765742775636467,0.505,10.8119083
+42.0,1.3802588406013947,0.5035,1.3782971197139013,0.5105,10.5043987
+43.0,1.3790158212449106,0.511375,1.3750078110329473,0.506,10.2630323
+44.0,1.372724890044871,0.513625,1.371686344085819,0.507,10.2913791
+45.0,1.3841243186840493,0.503125,1.3715707288847834,0.5085,10.483649
+46.0,1.3706965552017922,0.5105,1.372669460034513,0.509,10.5976056
+47.0,1.3609398421904124,0.515,1.3668745076784088,0.5155,10.5246735
+48.0,1.3684465174801346,0.510125,1.3672922703918313,0.5075,10.3461516
+49.0,1.3745615890314176,0.507875,1.3632436799025003,0.5155,10.4318952
+50.0,1.3661560620511515,0.512375,1.3656571720130959,0.5155,10.4115044
+51.0,1.3730880719325358,0.500625,1.364539772414789,0.5155,10.6619087
+52.0,1.3630051676931783,0.5035,1.3662467102323088,0.513,10.5240575
+53.0,1.3617572447747819,0.509,1.363957403159507,0.509,10.5144398
+54.0,1.362037085994588,0.5135,1.3589070650176729,0.519,10.3395114
+55.0,1.3498976297282788,0.51725,1.3599980371372662,0.515,10.5288365
+56.0,1.3516348408141448,0.5125,1.355870372282719,0.512,10.6001736
+57.0,1.3385261825204842,0.526625,1.3617299798150746,0.5095,10.5844011
+58.0,1.3437628067712626,0.521,1.3590337192716369,0.5195,11.1534123
+59.0,1.3474072046438994,0.518125,1.3566891621916062,0.5195,10.7746817
+60.0,1.3533470111880175,0.520375,1.357455364840804,0.513,10.6602748
+61.0,1.3545285545641799,0.518125,1.3505701147484508,0.5155,10.7175487
+62.0,1.341432704073239,0.522375,1.3493006314294527,0.513,10.6496625
+63.0,1.3379378898898793,0.522125,1.3484420742841998,0.517,10.6631501
+64.0,1.333203127708441,0.5235,1.3468148155245283,0.5165,10.6852211
+65.0,1.3377331720004932,0.523875,1.3493423460639042,0.5145,10.7314618
+66.0,1.3255920859867893,0.523375,1.3433875051505015,0.517,10.7242186
+67.0,1.3300511309513712,0.517875,1.3453225103876567,0.5125,10.4978694
+68.0,1.3358010310099961,0.52025,1.3453057215357858,0.5135,10.5691234
+69.0,1.3197357788742194,0.528875,1.3421916039075252,0.518,10.6167641
+70.0,1.3203685028518983,0.527625,1.3424124836025293,0.5165,10.6657817
+71.0,1.3307989670111722,0.5275,1.345739104299278,0.518,11.026438
+72.0,1.3322976095143777,0.52,1.3429779607884242,0.5155,10.644709
+73.0,1.3296559598508593,0.523625,1.3444630944044174,0.514,10.5105399
+74.0,1.3280188841512812,0.527625,1.34344221844315,0.516,10.6776355
+75.0,1.3307803581975912,0.523875,1.3410526207036906,0.516,10.7868019
+76.0,1.3244855340540875,0.527875,1.3438338429550298,0.523,10.6635871
+77.0,1.3305599130402717,0.525875,1.340556653020514,0.5175,10.5409209
+78.0,1.3235894138911644,0.525,1.3403516212495012,0.517,10.9057766
+79.0,1.3268468410443934,0.526875,1.3429226916224026,0.5165,10.7036664
+80.0,1.3149174365790721,0.535375,1.340394598387566,0.5175,10.6037911
+81.0,1.3181477089150777,0.52775,1.3403880188605957,0.5175,10.4741209
+82.0,1.319323285137216,0.535625,1.3411448601353022,0.5155,10.5985708
+83.0,1.3234409121785415,0.529875,1.3394094497030262,0.519,10.5946699
+84.0,1.3190738707359697,0.526625,1.3371803862718643,0.52,10.8042916
+85.0,1.321299521554079,0.52725,1.3373945919902914,0.5185,10.6818265
+86.0,1.3211808042865008,0.528375,1.3392930490633377,0.516,10.6868787
+87.0,1.3131869516551848,0.528,1.3373461343013249,0.5185,10.7746962
+88.0,1.3179359121893317,0.528125,1.3387782429660295,0.5215,10.7270818
+89.0,1.311048859808263,0.530375,1.3372642894972429,0.5205,10.7821707
+90.0,1.320080416323942,0.522125,1.3378657982403377,0.5225,10.9263664
+91.0,1.3249960621263235,0.528875,1.3370766774297338,0.516,10.6828557
+92.0,1.3251215286274038,0.525625,1.3377240399171442,0.5185,10.7313156
+93.0,1.3130120002893377,0.538625,1.3368735438414714,0.522,10.8578005
+94.0,1.310323171879521,0.531375,1.3350314192775283,0.5205,10.824233
+95.0,1.3190330018819567,0.526375,1.3354470971279013,0.52,10.6135388
+96.0,1.3151276322150627,0.530125,1.3359890385035038,0.519,10.6340359
+97.0,1.327150547563038,0.526375,1.336307085224182,0.5205,10.7083007
+98.0,1.3205413336573768,0.532875,1.3367641068052514,0.519,10.8156078
+99.0,1.3273791113771862,0.526,1.3379149870539122,0.5155,10.6449135
+100.0,1.3157120352111094,0.526375,1.3373280187315546,0.519,10.6634119
+101.0,1.3215741494524897,0.528,1.3357480757228959,0.52,10.6139632
+102.0,1.3072876094773205,0.535375,1.3354256884208593,0.5185,10.7655376
+103.0,1.3143488835661843,0.530375,1.3359342968082215,0.5205,10.8298254
+104.0,1.3152350251493992,0.529875,1.3356323643178725,0.5195,10.6298545
+105.0,1.3135973540956014,0.529875,1.3351536118568943,0.5205,10.6211939
+106.0,1.3154384582627792,0.530125,1.334427994455683,0.521,10.8536119
+107.0,1.3210255849454833,0.53075,1.334104218268996,0.5195,10.4814439
+108.0,1.3143402826039234,0.53025,1.3339928720989493,0.5205,10.7829616
+109.0,1.3157600089093793,0.528125,1.333472644524079,0.5215,10.5573774
+110.0,1.3025727092755095,0.53175,1.3345114392841104,0.5195,10.72651
+111.0,1.3036905203297846,0.543,1.3339360539982645,0.518,10.6090085
+112.0,1.3088988457929116,0.5365,1.3333981659049081,0.519,10.4973118
+113.0,1.3119720608457524,0.538,1.3335625353171354,0.52,10.7430242
+114.0,1.3043970085443117,0.531375,1.334056238140732,0.5195,10.4915247
+115.0,1.3017294163536326,0.538,1.3335915368020226,0.5205,10.4581882
+116.0,1.3222256067573879,0.53,1.3335446939318478,0.5195,10.4450988
+117.0,1.3093708948799567,0.53375,1.3334985225509113,0.5215,10.9147872
+118.0,1.3149674150150457,0.538375,1.3337427532687283,0.515,11.7424108
+119.0,1.30783044318407,0.534625,1.3331213359167602,0.5175,11.4566723
+120.0,1.3199277519272925,0.5365,1.3332143538891488,0.516,11.5086804
+121.0,1.3189351313090911,0.532875,1.3327645685240328,0.5175,11.1735311
+122.0,1.313889241231299,0.5335,1.333114587192607,0.518,11.1633045
+123.0,1.3136036409375527,0.534125,1.333415303606058,0.5185,10.8558689
+124.0,1.306055392924934,0.528125,1.333179197683708,0.5205,11.1664468
+125.0,1.313987180190348,0.528375,1.3328025895560218,0.518,10.6900298
+126.0,1.2997369106635803,0.534875,1.3325513330086356,0.52,10.8832755
+127.0,1.3043269154925206,0.542375,1.3323150254162253,0.5185,10.593046
+128.0,1.2990150090042205,0.538875,1.3319693238245163,0.519,11.3041431
+129.0,1.300840925692584,0.53425,1.332129167814571,0.5195,11.3470727
+130.0,1.3113424727787724,0.534875,1.3325362795103008,0.5195,11.4372106
+131.0,1.311164279965689,0.5365,1.3322504298740185,0.519,10.9763431
+132.0,1.3179274596479782,0.531875,1.33200920286141,0.52,11.0927249
+133.0,1.3065535362187486,0.5315,1.3320364020578384,0.5185,11.6468794
+134.0,1.3216960524997605,0.53075,1.332104347727303,0.5185,11.1033941
+135.0,1.2999653635760098,0.53725,1.3320147095564665,0.5195,11.2386502
+136.0,1.3009622714108506,0.53775,1.3320064297783212,0.52,10.8109444
+137.0,1.3020866795673038,0.537,1.3325281269574432,0.52,10.9768592
+138.0,1.2960008817160396,0.542,1.3321393427773633,0.521,11.7773318
+139.0,1.3070319913926276,0.529625,1.3320013928376542,0.522,11.2787995
+140.0,1.313324928250842,0.531125,1.332319248064813,0.52,10.8658981
+141.0,1.3113137255699068,0.5385,1.3322657782060892,0.5205,10.9917196
+142.0,1.2978898540401582,0.533125,1.3322607886380244,0.5195,10.9147804
+143.0,1.303700923738788,0.53675,1.3319811775751962,0.5195,10.8488982
+144.0,1.3080841313267175,0.535375,1.3320822880540282,0.5185,10.9062678
+145.0,1.3061468501882212,0.53525,1.3322048662060668,0.519,10.879839
+146.0,1.3068946425234962,0.5305,1.332217831301229,0.519,10.8861027
+147.0,1.301245090797761,0.539625,1.3320295634714883,0.5215,10.8577545
+148.0,1.3065219890435873,0.53575,1.332113688470487,0.5205,10.7260931
+149.0,1.3274100618369626,0.52925,1.3322692606852753,0.519,10.8736537
+150.0,1.3039974563257908,0.536375,1.3323550212708823,0.519,10.617175
+151.0,1.3043788657553899,0.534125,1.3323710546100196,0.52,10.9235931
+152.0,1.3032293971037556,0.534625,1.332047918810055,0.5175,10.6729111
+153.0,1.3014055210981292,0.54025,1.3321112066303324,0.52,10.676352
+154.0,1.3044298180448326,0.52725,1.3319157753576334,0.52,10.8311417
+155.0,1.3052974145137852,0.53225,1.3318265231488589,0.519,10.7265072
+156.0,1.294456826081973,0.538375,1.3320119341834187,0.519,10.5108274
+157.0,1.3055104415573224,0.5345,1.3322823839439082,0.5195,10.8981915
+158.0,1.3072999859432408,0.530875,1.3323840751470155,0.519,10.8914372
+159.0,1.3054355366673218,0.53575,1.332169356022742,0.518,10.7647776
+160.0,1.3102607607473018,0.534375,1.3322046300303008,0.519,10.8155812
+161.0,1.2996984915003205,0.529875,1.3321690463662035,0.519,10.8601054
+162.0,1.3071410221152815,0.537375,1.33216086525606,0.5195,10.8857956
+163.0,1.31125648643993,0.533,1.3322839485300493,0.5195,10.6960386
+164.0,1.3042658346167568,0.528125,1.3323380572495518,0.519,10.5043007
+165.0,1.3179450261006782,0.531125,1.3324363596005007,0.5185,10.7516799
+166.0,1.3094263423054922,0.531875,1.33248690377941,0.5195,10.7262958
+167.0,1.297266543693268,0.5335,1.3323895667281422,0.519,10.761302
+168.0,1.3151196165543917,0.531375,1.3323485730865656,0.5195,10.6862287
+169.0,1.309759919766804,0.527125,1.3324110180090327,0.5205,10.6801756
+170.0,1.3087049937365367,0.538,1.3322877029001738,0.52,10.7393492
+171.0,1.30327284892245,0.538375,1.332212064881177,0.5195,10.910512
+172.0,1.3082913965540677,0.538,1.3322312483131238,0.5185,10.9118247
+173.0,1.3011244178936303,0.536375,1.3321964417430978,0.519,10.7598359
+174.0,1.3072523127047047,0.52925,1.3320566621653582,0.5185,10.9707458
+175.0,1.3138588411240155,0.529125,1.3319687432258882,0.519,10.8912822
+176.0,1.3106422656372365,0.527125,1.3319979940470699,0.5185,10.6990858
+177.0,1.3066116025402963,0.529125,1.3319158310408483,0.519,10.7381856
+178.0,1.3098564706155673,0.533125,1.331847315213804,0.52,10.9513215
+179.0,1.306568765983263,0.5395,1.3318428764952057,0.5185,10.7053363
+180.0,1.2978578542689068,0.529875,1.3318802142109363,0.5195,10.8236495
+181.0,1.3104137239261946,0.532125,1.3318717953137231,0.5195,10.9077964
+182.0,1.3019511369585126,0.536125,1.3319202281095626,0.519,10.790271
+183.0,1.3026262283933931,0.53875,1.3319301787315239,0.519,10.764685
+184.0,1.3074215948491108,0.535125,1.3318929370446293,0.519,10.4456473
+185.0,1.3140615637521111,0.526375,1.3319417561631457,0.519,10.5469338
+186.0,1.303042511503874,0.535125,1.3319319551137805,0.519,10.4863691
+187.0,1.3023667289610636,0.53725,1.3319634830296754,0.5195,10.4730195
+188.0,1.313656540448708,0.5265,1.3319891322380029,0.519,10.4308219
+189.0,1.3045596261148191,0.5365,1.331928994460482,0.5185,10.7788625
+190.0,1.3133207158887825,0.53375,1.331957463512298,0.519,10.8276871
+191.0,1.3019403606497926,0.5405,1.3319362956789553,0.519,10.7438118
+192.0,1.3130384838114986,0.529375,1.3319535823904183,0.5195,11.608329
+193.0,1.3020558117475203,0.53325,1.3319106796555282,0.5205,10.9393292
+194.0,1.2948945544121986,0.534125,1.3319020806394841,0.5195,11.0815123
+195.0,1.3016977558412837,0.5385,1.3318488280353298,0.519,10.9919619
+196.0,1.309662422430833,0.526625,1.3318498862662658,0.519,10.9792706
+197.0,1.2986204486021442,0.534,1.3318447665439828,0.519,10.9207863
+198.0,1.3066933440609287,0.538125,1.3318181416738772,0.5195,10.8058765
+199.0,1.3057251708289193,0.5355,1.331810294677977,0.5205,10.6486611
+200.0,1.293281533921023,0.542875,1.3317618162361946,0.521,11.1699965
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_cifar.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_cifar.csv.mtd
new file mode 100644
index 00000000000..632e778e01b
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_cifar.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 200,
+    "cols": 6,
+    "nnz": 1200,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 09:29:20 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_mnist.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_mnist.csv
new file mode 100644
index 00000000000..30e1296eb54
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_mnist.csv
@@ -0,0 +1,30 @@
+1.0,1.2295765558414584,0.63825,0.40444866759503006,0.861,4.8348893
+2.0,0.26477554826363486,0.92175,0.26512101356030243,0.907,4.7804772
+3.0,0.1716384239702753,0.946625,0.1861527421595512,0.934,4.8846158
+4.0,0.13665724205968022,0.95825,0.15402649289072426,0.951,5.0159977
+5.0,0.11528498362904317,0.964625,0.13521963126212833,0.958,5.0522985
+6.0,0.10038067782344141,0.968875,0.1241082393421393,0.961,5.1249097
+7.0,0.08949871150603847,0.973,0.11534541975012162,0.963,5.2391965
+8.0,0.08047304771564,0.975875,0.1085638963229429,0.964,5.2079512
+9.0,0.07326581368947654,0.977375,0.1051219942722409,0.965,5.2237037
+10.0,0.06728259280373594,0.978375,0.10254733037683395,0.964,5.3218238
+11.0,0.06240274275974201,0.97975,0.10023146534197559,0.964,5.2897935
+12.0,0.05796746187582422,0.98125,0.09870775251419572,0.963,5.348292
+13.0,0.05362432700694249,0.982625,0.0976798211552113,0.964,5.4505141
+14.0,0.05031136069768907,0.983375,0.09599775800142536,0.965,5.3998741
+15.0,0.04736434754454498,0.9845,0.09561712478463401,0.965,5.4361032
+16.0,0.04433044920393202,0.985875,0.09517098972122923,0.964,5.5041032
+17.0,0.041435830650165074,0.986875,0.09454187141764388,0.965,5.4937658
+18.0,0.03898370691129355,0.98775,0.09440902006927702,0.964,5.576687
+19.0,0.03667472465419484,0.988375,0.09391787605699703,0.966,5.574709
+20.0,0.034633877224029566,0.989625,0.0929717653801862,0.966,5.6854783
+21.0,0.03275477720188584,0.9895,0.09293803088631118,0.966,5.6193843
+22.0,0.03102670424273144,0.991,0.09201967551518615,0.968,5.7005384
+23.0,0.029217136634823084,0.992125,0.09054231433213239,0.969,5.6793739
+24.0,0.02761085006294365,0.9925,0.08884571423403902,0.972,5.7013257
+25.0,0.02596455143980972,0.993,0.08824125932032173,0.973,5.7015987
+26.0,0.024384720182285775,0.993125,0.08671164308163506,0.974,5.7730918
+27.0,0.023003239637947995,0.994,0.08395146837679776,0.975,5.7459036
+28.0,0.021476007350274925,0.994375,0.08267510745699846,0.975,5.7748666
+29.0,0.020249484263020576,0.994625,0.08064123009465232,0.976,5.7539412
+30.0,0.01907369497589891,0.994875,0.07907412263084829,0.977,5.8177862
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_mnist.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_mnist.csv.mtd
new file mode 100644
index 00000000000..c0f572059d5
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_diagonal_mnist.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 30,
+    "cols": 6,
+    "nnz": 180,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 08:16:33 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_cifar.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_cifar.csv
new file mode 100644
index 00000000000..ba9f53b3579
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_cifar.csv
@@ -0,0 +1,200 @@
+1.0,2.3386543169511085,0.14075,2.301730941076264,0.102,13.2440651
+2.0,2.306853151644142,0.101,2.3055059732966208,0.094,7.0236308
+3.0,2.3029042375367226,0.100625,2.305089544740913,0.094,7.7217454
+4.0,2.302701369501017,0.100625,2.3048698641079537,0.094,7.4292454
+5.0,2.302605392210991,0.102125,2.3047226519023956,0.094,7.4588865
+6.0,2.3025403808407527,0.103,2.3046127102790064,0.094,7.440048
+7.0,2.302489931157983,0.103375,2.304525642874027,0.094,7.5205638
+8.0,2.302443250756605,0.104,2.304456188989574,0.094,7.4743448
+9.0,2.3024118126044075,0.1035,2.3043998604436697,0.094,7.5404491
+10.0,2.302382596182278,0.105,2.3043516836398195,0.094,7.5908392
+11.0,2.302357058853196,0.1055,2.304310472475333,0.094,7.6562841
+12.0,2.302328938804888,0.106375,2.3042523904340477,0.094,7.6313283
+13.0,2.3022267674540298,0.106625,2.303894057422064,0.094,8.15348
+14.0,2.29550364429792,0.11625,2.2418058113426813,0.1375,9.9689379
+15.0,2.229359245280139,0.16075,2.1798739550283135,0.197,12.0221511
+16.0,2.142310522382869,0.202125,2.1353315472476737,0.1985,11.9809247
+17.0,2.123674116460706,0.2015,2.1702792095485903,0.1825,13.029179
+18.0,2.093751733777236,0.2035,2.1175170779096515,0.1975,13.1877498
+19.0,2.084186559199693,0.205375,2.07455807738642,0.218,13.0843158
+20.0,2.0660901014816475,0.2115,2.0317926797671904,0.235,12.9275373
+21.0,2.035379634057953,0.224625,1.9881518961980784,0.246,12.6881631
+22.0,2.033972849762442,0.21975,2.041521747793386,0.22,13.4763186
+23.0,2.0264073632545907,0.2265,1.988690497044981,0.2495,13.5990838
+24.0,2.016342031253889,0.225625,2.003321523485824,0.2365,13.5518185
+25.0,2.0076863302594883,0.235,1.9925855431444786,0.2395,12.4195801
+26.0,1.9964585097411192,0.24375,2.0076889343010755,0.2715,14.2320017
+27.0,1.9901436791749099,0.262,1.9551231426033027,0.291,14.4629347
+28.0,1.9792639289794927,0.26075,1.9737146959790803,0.295,14.969736
+29.0,1.9601689618057947,0.266375,1.9430588801899498,0.2845,13.9720165
+30.0,1.9334580135889636,0.2835,1.8857903641875846,0.3135,14.7784468
+31.0,1.9031685148911583,0.298125,1.8472499120920443,0.3315,15.0640287
+32.0,1.8653301464645862,0.313,1.880057835111283,0.318,15.231095
+33.0,1.8523565124991404,0.316375,1.7725017171266015,0.376,13.5756948
+34.0,1.8342618088226075,0.318125,1.7800508210888095,0.3605,14.9955639
+35.0,1.8336460095065896,0.323125,1.787985185196742,0.3625,15.0110407
+36.0,1.820009047112316,0.329,1.756658638539667,0.3725,14.9862536
+37.0,1.8077631379347214,0.34175,1.7717681762030202,0.364,13.2135801
+38.0,1.788524631007008,0.34575,1.7619589229079804,0.375,15.0620062
+39.0,1.791772084842116,0.341,1.7433679877617634,0.3745,15.0021848
+40.0,1.7791772301611484,0.350125,1.7666157785818999,0.3615,14.9352203
+41.0,1.7746364279319866,0.3455,1.7037150476856802,0.3865,13.3385737
+42.0,1.7713700859606532,0.348875,1.690746168912098,0.387,15.09774
+43.0,1.7713734661248577,0.357875,1.6821605272530649,0.397,15.084371
+44.0,1.7626256890693348,0.35825,1.6837801895121312,0.3935,15.0211462
+45.0,1.7598394151926655,0.354625,1.6740982465868872,0.396,13.3357733
+46.0,1.7539472254744364,0.353125,1.6616898280133225,0.4025,15.2044539
+47.0,1.7538892372159576,0.356625,1.6674473152492373,0.4005,15.0903358
+48.0,1.7539859251331373,0.355125,1.6532536625339793,0.406,14.2919023
+49.0,1.7503969987338617,0.360625,1.6596524329149054,0.4015,14.4817916
+50.0,1.7381123098469948,0.363625,1.656266615649999,0.4025,15.18977
+51.0,1.7342730483969653,0.36325,1.649063863923143,0.4085,15.2124864
+52.0,1.726664700259063,0.363875,1.6494641351454633,0.4075,13.4775783
+53.0,1.7382815597254464,0.370375,1.6484416930601533,0.4085,15.2558147
+54.0,1.7409957010600818,0.36775,1.6400315212566994,0.405,15.1423003
+55.0,1.7380013725836077,0.364375,1.6584235844255384,0.4,15.1819791
+56.0,1.7252254751778295,0.3635,1.6408861354062723,0.412,13.4598759
+57.0,1.7270343866662905,0.362375,1.6341325378487244,0.408,15.2166579
+58.0,1.737977273737201,0.362375,1.6488951299150223,0.4075,15.2679731
+59.0,1.7271689163479547,0.37025,1.6263575944857598,0.413,13.6802149
+60.0,1.7254958413260688,0.3705,1.6315380083120286,0.41,15.2781708
+61.0,1.7181007013044454,0.371,1.6306000717210887,0.4095,15.2280359
+62.0,1.72465079487459,0.364,1.6293561227887043,0.4125,15.507153
+63.0,1.7132400396298113,0.36975,1.626621678750916,0.4135,13.5328102
+64.0,1.7052291677708586,0.3745,1.6210421736276142,0.418,15.3551155
+65.0,1.701867702308963,0.374875,1.6242193103132556,0.4115,15.2727139
+66.0,1.7135358624290584,0.37275,1.6146568323834238,0.419,14.0423824
+67.0,1.7132997176567093,0.371125,1.6172238887195471,0.4205,14.937948
+68.0,1.707521528490376,0.37475,1.6163527913678302,0.4125,15.3428662
+69.0,1.7156805062510991,0.3725,1.6154714246838635,0.4235,15.3497089
+70.0,1.7103624979123697,0.371875,1.6149679063226405,0.4185,13.430805
+71.0,1.7022264497260884,0.37825,1.6189648275144843,0.417,15.3303315
+72.0,1.704999712929571,0.377125,1.6076234744379985,0.425,15.1685186
+73.0,1.7122475371935677,0.37575,1.6128861077870231,0.422,14.68165
+74.0,1.7105726409252495,0.37675,1.6133535284180793,0.4185,14.3623111
+75.0,1.7120967718183928,0.3725,1.6157060009382196,0.415,15.3808897
+76.0,1.709805311172322,0.379,1.6140482812903327,0.417,15.2044063
+77.0,1.693896104078977,0.375125,1.6066355977229072,0.42,13.5269637
+78.0,1.7086734022994816,0.3715,1.6048202835547072,0.42,15.3090831
+79.0,1.7107539978546311,0.382,1.6079807462854248,0.418,15.2142229
+80.0,1.702670634036159,0.377875,1.61275913226515,0.4125,15.4079025
+81.0,1.7056573851314771,0.374125,1.6046630025493709,0.4235,13.5786103
+82.0,1.6975011461960405,0.3805,1.6009267801582263,0.423,15.4458054
+83.0,1.6928633472234556,0.382625,1.605161223911461,0.42,15.2581137
+84.0,1.6877870754748503,0.376875,1.598526014748025,0.4265,13.5425535
+85.0,1.6929905072113842,0.38,1.6032255349219975,0.4225,15.4009236
+86.0,1.6976864219800303,0.378125,1.5996898462747446,0.4275,15.4060508
+87.0,1.6995788055313272,0.38475,1.5997161127296189,0.4275,15.3564231
+88.0,1.6981842472525697,0.379875,1.5992687407447719,0.4275,13.5606273
+89.0,1.7032698390679553,0.373,1.603501228526589,0.4255,15.3838471
+90.0,1.7000317932542064,0.38075,1.5995587290290691,0.422,15.2790385
+91.0,1.6912479590477112,0.3845,1.6011868422735624,0.423,13.505124
+92.0,1.6983303612731993,0.378875,1.6002630969829654,0.423,15.3999124
+93.0,1.6789260073774237,0.388125,1.5963635859077472,0.4225,15.2177478
+94.0,1.6909163785079173,0.378625,1.589221689671725,0.4275,15.3725809
+95.0,1.6919853479142575,0.385375,1.5934452565755204,0.4265,13.4818736
+96.0,1.6990413560659319,0.375375,1.5975081378907166,0.427,15.3572804
+97.0,1.6999366796814561,0.36975,1.591890290822412,0.428,15.3061407
+98.0,1.685029744720875,0.381125,1.5946490682856835,0.4275,13.5822646
+99.0,1.6874998730987087,0.38775,1.594871545984272,0.425,15.3221043
+100.0,1.69273681345158,0.381125,1.5942024752474329,0.428,15.4726346
+101.0,1.6838655988515068,0.385875,1.5911119244789025,0.4275,15.3040142
+102.0,1.6837849565215437,0.38575,1.5920130032978597,0.4275,13.5849855
+103.0,1.689637797014383,0.385,1.5904492220182849,0.4285,15.4492019
+104.0,1.6886520432099212,0.386,1.5912814439026033,0.427,15.4394833
+105.0,1.6890147004636586,0.388875,1.588632761329223,0.431,13.6054946
+106.0,1.703430317835904,0.374375,1.5895182286029685,0.4315,15.446289
+107.0,1.6953541367526648,0.376875,1.590694051057957,0.4295,15.3398089
+108.0,1.68303557594824,0.379625,1.5897667623333334,0.4305,15.4276704
+109.0,1.6937751436354298,0.375625,1.590384041191102,0.4275,13.6274101
+110.0,1.6931847774731332,0.3785,1.5890310243598322,0.43,15.4850877
+111.0,1.6881081318300872,0.385,1.5884077321812178,0.4305,15.3959146
+112.0,1.7002088445228072,0.38225,1.5892000661490608,0.4285,13.8162308
+113.0,1.698733947315805,0.37925,1.5899565453826858,0.4285,15.3936976
+114.0,1.6921351777066116,0.379,1.587732076210329,0.43,15.4659813
+115.0,1.6842771553009004,0.380625,1.5868784756157346,0.4285,15.46463
+116.0,1.6836485036327553,0.38225,1.5884831668792907,0.428,13.650455
+117.0,1.6829108627796128,0.389875,1.5894439750995353,0.427,15.4808514
+118.0,1.687492807727144,0.383875,1.587582875265481,0.4295,15.4860714
+119.0,1.6935608290660495,0.3795,1.5889665229432852,0.4275,13.6095219
+120.0,1.692320313057568,0.376125,1.5887843882934605,0.4295,15.5656657
+121.0,1.6924146604371193,0.380625,1.5882626541406375,0.429,15.5208246
+122.0,1.690012666859895,0.38625,1.5871813967444837,0.431,15.4396337
+123.0,1.6794978819455646,0.38175,1.5871991726488208,0.43,13.6830272
+124.0,1.6926994158016195,0.377875,1.5882365672557917,0.431,15.4183431
+125.0,1.6908961974544536,0.387625,1.5878734133897638,0.43,15.316937
+126.0,1.6893128794654224,0.38075,1.5870830733644223,0.43,13.6248053
+127.0,1.7000015647543092,0.375125,1.5878335143550357,0.429,15.3336629
+128.0,1.6858226188091008,0.384875,1.5870843048812404,0.4295,15.5078571
+129.0,1.6899238394375566,0.383125,1.5870214680172545,0.43,15.4230317
+130.0,1.6970789219675935,0.374125,1.5872033916369521,0.429,14.1680863
+131.0,1.6820761405399696,0.383875,1.5869233456969811,0.4295,15.3963615
+132.0,1.687902460458744,0.383875,1.5864022102044886,0.4295,15.3919471
+133.0,1.7003253824201146,0.38025,1.5861638139521703,0.4275,13.7236074
+134.0,1.691768846180353,0.3785,1.58660031101729,0.428,15.3962918
+135.0,1.6757454282159554,0.38375,1.5873239424805365,0.4275,15.4047804
+136.0,1.6839341372203576,0.388125,1.586107763628232,0.4285,14.4468931
+137.0,1.6851595999266489,0.38525,1.5866514654210415,0.4275,14.7148097
+138.0,1.6895058659092632,0.382625,1.5858813471126203,0.4315,15.4495024
+139.0,1.6904830590658082,0.378875,1.5859974918669153,0.429,15.4072306
+140.0,1.6854879366651503,0.38475,1.5865065338739601,0.4285,13.6094411
+141.0,1.6969478539323126,0.378375,1.586849947244484,0.4275,15.4554722
+142.0,1.6871623395541377,0.38375,1.5870799447975714,0.4275,15.4324881
+143.0,1.6923125617065737,0.371625,1.5871416849716256,0.428,14.3429431
+144.0,1.6821539367762521,0.38125,1.5865588931249075,0.4285,14.7712782
+145.0,1.6903909160857566,0.378,1.5860616530789373,0.431,15.3883726
+146.0,1.6836464701159342,0.38525,1.5864408073000216,0.429,15.4214137
+147.0,1.6871807499364007,0.382875,1.585986801398567,0.429,13.6416271
+148.0,1.6854665285387964,0.384875,1.5860963248632833,0.43,15.3278486
+149.0,1.6725886064474143,0.381625,1.5865046325146315,0.429,15.2909046
+150.0,1.6792273858018316,0.38975,1.5862265450383235,0.428,13.6312723
+151.0,1.6906159325651955,0.388875,1.5871780519732297,0.428,15.3713903
+152.0,1.6863341244339474,0.38625,1.5870150555995144,0.43,16.5433147
+153.0,1.681956552726487,0.381875,1.5860159873341555,0.43,15.7907327
+154.0,1.6763457706493239,0.39125,1.5856159026871037,0.4295,14.1020194
+155.0,1.6878906319655413,0.38525,1.5854738161249688,0.43,15.8203634
+156.0,1.6884639306784512,0.383625,1.5858198660966825,0.4295,15.981796
+157.0,1.6922245572293098,0.3835,1.585450766142147,0.4295,13.9871211
+158.0,1.6837414669281217,0.38675,1.5858054482397583,0.429,15.6782996
+159.0,1.6827408015069112,0.388,1.5851766986452365,0.428,16.5450602
+160.0,1.6822361975373656,0.385375,1.585587716802313,0.4305,16.1751157
+161.0,1.6924068390862042,0.385375,1.5856475374280188,0.4305,13.6632845
+162.0,1.6853950028273168,0.384,1.5858628783955222,0.43,15.503817
+163.0,1.686356493301556,0.383,1.5855189270462533,0.4295,16.1090347
+164.0,1.686867662679916,0.375,1.5856657209926603,0.43,13.8722326
+165.0,1.6874301538456327,0.38375,1.5857448608473028,0.4295,15.774227
+166.0,1.693109929685849,0.384,1.5861631389520925,0.4285,15.6488884
+167.0,1.6796101134236943,0.379125,1.5857977275688675,0.43,16.4700145
+168.0,1.681520783515229,0.388125,1.5857790711970532,0.429,14.1852453
+169.0,1.687637838833695,0.378375,1.585865275167134,0.43,15.8195832
+170.0,1.6928045054909764,0.383875,1.5858695163145378,0.4285,15.8993575
+171.0,1.6841367965298017,0.38275,1.5860559457431749,0.429,14.1741843
+172.0,1.6865338283860034,0.38775,1.5859487070179679,0.429,16.2752338
+173.0,1.6784874510527448,0.39225,1.5859677329806865,0.429,16.6155572
+174.0,1.69070079247893,0.381125,1.5861027397118088,0.4285,17.5706886
+175.0,1.687900832688665,0.384875,1.586369163037136,0.428,14.5073584
+176.0,1.6825990730643612,0.385125,1.5859902444281095,0.429,16.8389949
+177.0,1.6903275758094556,0.37875,1.585857852195248,0.429,16.2755825
+178.0,1.6899771287369825,0.38525,1.5862460878293156,0.428,14.7914186
+179.0,1.689442773092312,0.376875,1.5861651359975653,0.428,16.734763
+180.0,1.6973046454060805,0.386625,1.5861896625513374,0.4285,16.7220156
+181.0,1.6787948339837928,0.393375,1.5858423933158525,0.4295,16.5265661
+182.0,1.686334812355981,0.3865,1.585999150063282,0.428,13.8054375
+183.0,1.6807187943431512,0.3845,1.5857793268734903,0.4295,15.5851119
+184.0,1.680048305050793,0.3845,1.585611871893802,0.4285,17.0678644
+185.0,1.686647722453985,0.385875,1.585337343670542,0.4295,14.517266
+186.0,1.6774368891557536,0.38825,1.5853310311278104,0.429,16.4339002
+187.0,1.6900446961100217,0.38075,1.585453255051558,0.429,15.9561385
+188.0,1.6882838471530937,0.38625,1.5855422860383177,0.4285,15.7107715
+189.0,1.6857764016419219,0.387625,1.5854703899591769,0.4285,14.4953238
+190.0,1.6812043403220969,0.386625,1.5855096261624553,0.429,16.2408232
+191.0,1.6813677278615276,0.385125,1.5855218326222813,0.429,16.334702
+192.0,1.6795154919651627,0.382625,1.5855701296099058,0.429,14.1359716
+193.0,1.6848002800063229,0.387,1.585484081884541,0.429,15.8233924
+194.0,1.6982066391674726,0.381375,1.585539031585177,0.4295,16.250603
+195.0,1.6889067835981957,0.38075,1.5857727124471617,0.429,15.7038991
+196.0,1.6799841921142904,0.38575,1.585742285592279,0.429,14.8943664
+197.0,1.6820144342165013,0.38575,1.5855546538095147,0.4295,16.69676
+198.0,1.6860069308374512,0.388,1.5852642548044042,0.4295,16.7627703
+199.0,1.673462897537824,0.3915,1.5851789779517098,0.43,14.3834255
+200.0,1.6864993365881753,0.3795,1.5854621306917878,0.429,17.1495746
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_cifar.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_cifar.csv.mtd
new file mode 100644
index 00000000000..828cb9698cb
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_cifar.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 200,
+    "cols": 6,
+    "nnz": 1200,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-15 17:26:38 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_cifar.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_cifar.csv
new file mode 100644
index 00000000000..a8310509791
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_cifar.csv
@@ -0,0 +1,200 @@
+1.0,2.3578557887351503,0.127,2.2831586657173353,0.117,12.2236136
+2.0,2.290579345600647,0.112375,2.2599101039589202,0.117,13.1504781
+3.0,2.259876580378829,0.140375,2.190075441997353,0.19,12.7150741
+4.0,2.2123124925882016,0.173,2.1669796925443703,0.1865,14.0307481
+5.0,2.166996186252336,0.18825,2.057032955581059,0.2615,14.5334107
+6.0,2.0901064992160854,0.222375,1.9675302080428219,0.286,15.0818033
+7.0,2.013819524745611,0.258375,1.9133536664070094,0.302,15.1464027
+8.0,1.9737515767550637,0.2755,1.8628096148659337,0.3245,15.5779899
+9.0,1.9374155646339761,0.28425,1.8213905138948094,0.3245,15.5606504
+10.0,1.8903700818031115,0.303625,1.7948572826062223,0.3335,14.149382
+11.0,1.865546397793384,0.31625,1.7321936294291116,0.356,15.7005658
+12.0,1.8356664682549544,0.33125,1.7496619874034676,0.3635,15.6023952
+13.0,1.8021405768559393,0.3505,1.690730207328495,0.384,15.6208546
+14.0,1.7797370219542088,0.348,1.6963849584703392,0.3925,15.6920447
+15.0,1.7666712229633776,0.358125,1.708665893101907,0.3835,15.5287662
+16.0,1.7450442809786055,0.366875,1.6625775635560047,0.3865,15.5169449
+17.0,1.7117889133914013,0.375625,1.6086421432931646,0.4185,15.5266343
+18.0,1.6919193766466378,0.384,1.6054825473227123,0.4175,15.4257219
+19.0,1.6632078021756036,0.391375,1.6288545159855077,0.4115,15.43522
+20.0,1.6613741691155957,0.392,1.5680806717710423,0.4275,15.3289755
+21.0,1.619924805543468,0.412625,1.5465452534635618,0.4285,15.3282209
+22.0,1.6160630277237045,0.411,1.550992263036037,0.425,15.4077311
+23.0,1.6052175401738582,0.41725,1.5282966200898573,0.4305,13.6931284
+24.0,1.585906683721859,0.423375,1.5166766394507396,0.4445,15.1885039
+25.0,1.5732263235986785,0.42425,1.5128602545718595,0.442,15.7604111
+26.0,1.5821843166645668,0.41975,1.513900700717286,0.432,13.718303
+27.0,1.5698889652699637,0.433375,1.5250589184085934,0.4405,15.3884628
+28.0,1.5619760908392646,0.43675,1.5043176617046117,0.4555,13.6728122
+29.0,1.5596303261580569,0.431,1.4865147935033893,0.4605,15.4715643
+30.0,1.5501695546505512,0.435,1.4862708820220933,0.4525,13.5416479
+31.0,1.542548934652783,0.444625,1.4892523345468474,0.4545,15.5810621
+32.0,1.5342478236165886,0.441875,1.4800582095190418,0.4585,13.6371874
+33.0,1.5292448567982906,0.442375,1.4669349211801785,0.474,15.5371402
+34.0,1.5182126152893296,0.447125,1.475864972723064,0.4545,13.7075043
+35.0,1.5110971443878898,0.45625,1.4705142606940091,0.458,15.5589255
+36.0,1.5199600712772678,0.45125,1.489661397966485,0.4575,13.6878869
+37.0,1.4927654641676709,0.454,1.467439092814473,0.466,15.531781
+38.0,1.4948461758696592,0.46125,1.4490079459667489,0.4685,14.5857949
+39.0,1.4918591528247425,0.46,1.4569872177991534,0.4685,15.6324133
+40.0,1.4800146494075497,0.46375,1.470197574909571,0.4675,13.7671721
+41.0,1.480266260987431,0.46025,1.435466124726762,0.4815,16.4634696
+42.0,1.4663583020289601,0.470125,1.4315558300175752,0.4815,14.6995721
+43.0,1.4611874316879079,0.472875,1.4291748734084397,0.4845,15.5487899
+44.0,1.46129813499749,0.46625,1.4320028551847455,0.4745,13.8951668
+45.0,1.4665816751688794,0.472125,1.4339987164520875,0.482,15.5613458
+46.0,1.4551893139522587,0.47425,1.4262095859977861,0.487,13.7835234
+47.0,1.4690645407253038,0.468625,1.4204162903236368,0.4885,15.4783984
+48.0,1.4599160719222943,0.475,1.4248899482762345,0.4855,13.7698484
+49.0,1.4566605552109801,0.47,1.4216157130342515,0.484,15.4621436
+50.0,1.447717760532665,0.479375,1.4250449013770714,0.48,13.9294422
+51.0,1.437806380872101,0.48625,1.4160565750404084,0.4785,15.4871456
+52.0,1.4432825740786184,0.47775,1.4202514635572692,0.4865,13.8851062
+53.0,1.44463340272832,0.4765,1.4175851917572133,0.4845,15.6623871
+54.0,1.451938577051031,0.475875,1.425143809030958,0.4785,14.8936695
+55.0,1.44110717492481,0.478375,1.41470848167406,0.487,19.1872065
+56.0,1.435464820163631,0.4815,1.4081762776725488,0.491,15.3621055
+57.0,1.4288538971104097,0.486125,1.41378619891076,0.4835,15.9713463
+58.0,1.4460401725867442,0.475625,1.4124346427225476,0.4885,13.999068
+59.0,1.435180946362223,0.482125,1.4094683341405312,0.4895,16.800066
+60.0,1.4327815846912868,0.4855,1.4046018909816949,0.492,13.9497476
+61.0,1.4325856379095134,0.484375,1.4059675414095518,0.494,17.9197221
+62.0,1.4291569684534067,0.48,1.400332762771656,0.489,14.5538948
+63.0,1.4219982857346853,0.486625,1.3970289499931685,0.495,15.7821386
+64.0,1.4182059402374125,0.488625,1.400833673485251,0.489,13.9950954
+65.0,1.4195473871650708,0.486375,1.3979501252647686,0.493,17.6774702
+66.0,1.4232736928295164,0.483,1.3983704535335444,0.4855,14.4360364
+67.0,1.421551989755518,0.4855,1.397889088430559,0.4935,17.7797958
+68.0,1.413560874623841,0.489625,1.4006753172044049,0.493,14.32286
+69.0,1.4265113978118376,0.481,1.3970420406768869,0.494,15.6475242
+70.0,1.4261365106177653,0.483125,1.3985393276663705,0.4915,14.027412
+71.0,1.4161164008348488,0.49225,1.3985864796248797,0.491,15.4938534
+72.0,1.4259967552214254,0.490625,1.3945541541966286,0.491,13.5528966
+73.0,1.4234480018588245,0.482,1.393501487288358,0.496,15.4509737
+74.0,1.4183868459944677,0.4905,1.3972153508724983,0.49,13.5829926
+75.0,1.415975832481686,0.488875,1.3945415423533454,0.49,15.4572837
+76.0,1.4137106773331642,0.493,1.3949387782555436,0.4895,13.5858074
+77.0,1.407563039713408,0.48825,1.3945189358636259,0.494,15.6904307
+78.0,1.4161407348166761,0.49725,1.3968541844066253,0.49,14.1936055
+79.0,1.41082925045235,0.493125,1.3915600707496503,0.4965,16.0369722
+80.0,1.407531019966082,0.497125,1.3891041172315384,0.4965,13.879934
+81.0,1.4143762023373787,0.492375,1.389543419961976,0.498,16.1709713
+82.0,1.4010948110384127,0.501125,1.3905496940103907,0.497,15.5447567
+83.0,1.3975022366918521,0.49425,1.3887178652911785,0.494,13.5909262
+84.0,1.4073924909298157,0.491,1.3886342777438223,0.496,15.4333049
+85.0,1.407335627871086,0.492375,1.3880521602774607,0.499,13.5460918
+86.0,1.3993379527408807,0.489625,1.3864861830005113,0.498,15.3514156
+87.0,1.4107472493085969,0.491125,1.387909002130466,0.4975,13.7630284
+88.0,1.4091185550676968,0.49675,1.3879870212969472,0.498,15.3269184
+89.0,1.4065874894372707,0.496125,1.3885835647950597,0.4975,13.5169058
+90.0,1.3973368206156953,0.49225,1.3887803002902355,0.4985,15.3649952
+91.0,1.4041950913842653,0.49725,1.3895534915226555,0.4965,13.5559162
+92.0,1.4024062464325768,0.495625,1.386535331990313,0.5,15.3257995
+93.0,1.3990050380297427,0.491,1.3857530643210278,0.5005,13.4729962
+94.0,1.4027787617356107,0.496,1.3893285744619996,0.499,15.3636517
+95.0,1.401049705402974,0.500125,1.3879682185842706,0.499,13.4351827
+96.0,1.4087284034633765,0.4885,1.387156162598021,0.4975,15.7297076
+97.0,1.4142099163851078,0.4965,1.3891480518420873,0.498,13.970082
+98.0,1.4046857127847048,0.488875,1.387397222746437,0.499,15.8655113
+99.0,1.3987614173553458,0.497125,1.3882776133666892,0.495,14.3087639
+100.0,1.402649947173708,0.49075,1.3876080953484173,0.4945,16.4156547
+101.0,1.4055813169167695,0.492375,1.38754417920826,0.4965,14.3686621
+102.0,1.395343091463629,0.500625,1.384574561930633,0.5035,16.2329499
+103.0,1.4011602620188688,0.494625,1.3849398293100237,0.504,14.0644375
+104.0,1.3970571509337748,0.499875,1.3856719685818204,0.5045,15.7672199
+105.0,1.3976512348981756,0.497125,1.3854529672196398,0.5035,14.9459157
+106.0,1.4022147575152173,0.493875,1.385428420492798,0.505,16.1238784
+107.0,1.400539600131114,0.50175,1.3838452992186754,0.504,14.1168296
+108.0,1.4030561344430086,0.49325,1.3842067014907216,0.5025,15.6359261
+109.0,1.4063934878796418,0.48925,1.3860886483211372,0.5025,13.6504704
+110.0,1.4051149900521684,0.488875,1.3849158029915123,0.5045,15.5044806
+111.0,1.4001584345334,0.492,1.3852677362721162,0.504,13.7843918
+112.0,1.4068725940910731,0.490875,1.38445869103932,0.504,16.0680476
+113.0,1.4022106226497297,0.489625,1.3860103679865754,0.5025,13.8299267
+114.0,1.3995335375298494,0.49375,1.3860651089640434,0.5015,15.7922341
+115.0,1.400503687348999,0.48975,1.3852569594485673,0.5015,14.0225566
+116.0,1.3966020815793994,0.49575,1.3844809469580266,0.505,15.8714818
+117.0,1.4105144698566157,0.493375,1.384121811569296,0.502,13.6426427
+118.0,1.4125510913320924,0.48525,1.3845196302842364,0.5035,15.6862597
+119.0,1.3989033060118337,0.493125,1.3831946048399872,0.503,13.7632232
+120.0,1.4032152181600865,0.496,1.3855581527068392,0.4985,15.7394284
+121.0,1.3988681974602644,0.491625,1.3844494989996838,0.5015,15.6030773
+122.0,1.3950277130253677,0.50375,1.3838707740109528,0.502,15.6065003
+123.0,1.3898302866507375,0.502875,1.383915879207389,0.503,13.7968901
+124.0,1.4035000792445513,0.494,1.3831081883678855,0.5045,15.6726591
+125.0,1.4057160509092983,0.4875,1.383104454951081,0.506,13.6661516
+126.0,1.4006921514586976,0.4955,1.3834568425390648,0.503,15.6107837
+127.0,1.4055961595758415,0.49225,1.3836698494554445,0.503,13.7570813
+128.0,1.4130403376832452,0.49325,1.383975039325702,0.504,15.6788563
+129.0,1.3901234340273052,0.495375,1.3840354024969157,0.504,13.7543542
+130.0,1.387628968695257,0.50325,1.3842585241472747,0.5055,15.6189025
+131.0,1.396140836648794,0.505375,1.3845285303323958,0.504,13.8195172
+132.0,1.3992754444242221,0.494125,1.3840551948087276,0.5035,15.9616324
+133.0,1.3900047557283237,0.49975,1.3845045559770106,0.502,13.7343467
+134.0,1.4094271596346226,0.493625,1.384743449684079,0.503,15.617925
+135.0,1.4029004963603224,0.497375,1.384629196030117,0.505,13.7740788
+136.0,1.38981933900675,0.498875,1.3837472183078396,0.5055,15.6722476
+137.0,1.390877335150279,0.499,1.3834342753703313,0.505,13.7584896
+138.0,1.3923837510602344,0.50075,1.3832670351043763,0.504,15.5770014
+139.0,1.3883020183513597,0.497375,1.382435943463765,0.5055,13.8964198
+140.0,1.3918689012185077,0.494,1.3830131642208616,0.5035,15.6422692
+141.0,1.4039123940331173,0.494875,1.3829432038489289,0.503,13.6727981
+142.0,1.3896969698050174,0.499,1.3833011114100755,0.503,15.9513211
+143.0,1.39201782120047,0.501,1.3832875347917437,0.5035,13.7021309
+144.0,1.4050578038226598,0.492875,1.3830038459295741,0.504,15.6819382
+145.0,1.3865105891403073,0.500375,1.3827551445775557,0.503,13.6406593
+146.0,1.3965918286348946,0.4965,1.3835646071850352,0.502,15.8773205
+147.0,1.3999049573667315,0.492375,1.383326908435256,0.5025,13.8077648
+148.0,1.3936567516400624,0.50025,1.3835365565840425,0.5015,15.7759605
+149.0,1.3959644683247479,0.494,1.3834084661257897,0.5035,13.9374024
+150.0,1.3884447659627033,0.50175,1.3829955403527563,0.5045,16.3715655
+151.0,1.3962198887058612,0.495375,1.382838126289804,0.505,14.8958379
+152.0,1.4008984872315056,0.49725,1.3830868308810906,0.505,16.2607087
+153.0,1.405106918683159,0.48825,1.3832661929477479,0.5045,13.9988522
+154.0,1.3915006292386802,0.50275,1.3829780797178992,0.504,16.042155
+155.0,1.391004352520092,0.5005,1.3830180718878164,0.5025,14.0802696
+156.0,1.3923211752741045,0.50175,1.382985502840576,0.503,15.8148489
+157.0,1.4041786986865317,0.497875,1.3835048945661745,0.502,13.7750587
+158.0,1.4016955230860424,0.495375,1.383217421409712,0.5035,15.6503513
+159.0,1.3980511580629338,0.499625,1.3832032218503227,0.504,13.732946
+160.0,1.3829542717850556,0.5095,1.3825925879595662,0.504,15.6051886
+161.0,1.3875359099923925,0.49825,1.3827759939885853,0.5035,13.7298119
+162.0,1.413167987907386,0.49075,1.3826867393909152,0.5035,15.6136468
+163.0,1.4030912065747152,0.494875,1.3829358155672664,0.5035,13.7618302
+164.0,1.3946387561135805,0.4945,1.382840025716245,0.5035,15.6612857
+165.0,1.398713693518451,0.50025,1.3829774410167497,0.5035,13.7390685
+166.0,1.396998315418331,0.497375,1.3830676034360176,0.5035,16.3453138
+167.0,1.3955577261401846,0.50075,1.3830902261051767,0.5035,14.3911335
+168.0,1.3988853539913237,0.48975,1.3830180969978216,0.5025,16.7471628
+169.0,1.4093234017669038,0.490125,1.3831035911887197,0.503,14.2703948
+170.0,1.387005171514562,0.507875,1.3828799356323076,0.5045,16.2012438
+171.0,1.393070923476958,0.496625,1.3828563713993758,0.5045,14.3381304
+172.0,1.396904210197886,0.489125,1.3826125638876436,0.504,16.4485602
+173.0,1.3833820915446526,0.499,1.3825213731766943,0.505,14.0757611
+174.0,1.3931729362661576,0.496875,1.3826629078598311,0.504,16.0487858
+175.0,1.3956512436818358,0.49675,1.3828076671310645,0.5035,14.0923034
+176.0,1.400443999833515,0.494,1.3827162705127485,0.5035,15.7638616
+177.0,1.3812218777714491,0.499875,1.3827988383253642,0.505,13.7681779
+178.0,1.392146169245651,0.497,1.3827227272044316,0.5055,16.3485031
+179.0,1.3967549513798534,0.499875,1.3827573507870048,0.5055,13.8779946
+180.0,1.3999380833136357,0.497125,1.3826473455450088,0.505,15.7251239
+181.0,1.4003831291106263,0.49125,1.3826710862161784,0.505,13.5663197
+182.0,1.3956567813746823,0.496625,1.3827160100406575,0.505,15.6326484
+183.0,1.3992026783462674,0.4985,1.3827543840344505,0.5055,13.9391901
+184.0,1.392310898218398,0.498,1.382744803969001,0.5055,16.0548293
+185.0,1.3902949594346201,0.502625,1.3826057882774299,0.505,14.0266826
+186.0,1.3945524645807796,0.500625,1.3825970656129722,0.5055,15.8452358
+187.0,1.4026273267951386,0.492375,1.3825762466577218,0.5055,13.9976586
+188.0,1.382746492611655,0.500625,1.3824662080629395,0.5055,15.8777556
+189.0,1.3862457694922095,0.4985,1.3824024206158323,0.505,13.8559148
+190.0,1.4011666509036005,0.493125,1.3823872274582762,0.505,15.9917833
+191.0,1.4011546564775808,0.496625,1.3824078414353653,0.505,14.0627787
+192.0,1.3929999733661478,0.499625,1.3824688822876676,0.505,15.9565214
+193.0,1.4000741941974273,0.493875,1.3824429295181224,0.505,14.2448323
+194.0,1.3854775319429742,0.502,1.3822743869418963,0.505,16.0736746
+195.0,1.3961519847445818,0.49625,1.3823671456915163,0.505,14.3862475
+196.0,1.4136537391722335,0.487,1.3823641975838246,0.505,16.2638135
+197.0,1.3956329021533984,0.4975,1.3823624006347233,0.5045,14.0787797
+198.0,1.3968799700816734,0.497125,1.382414763659396,0.5045,15.5971037
+199.0,1.3899817976102402,0.498875,1.3823728837294411,0.5045,13.77807
+200.0,1.398741816673307,0.492625,1.3824793385707603,0.504,15.7196366
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_cifar.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_cifar.csv.mtd
new file mode 100644
index 00000000000..85e79d5aa22
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_cifar.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 200,
+    "cols": 6,
+    "nnz": 1200,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 11:14:29 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_mnist.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_mnist.csv
new file mode 100644
index 00000000000..6f72e8ea740
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_mnist.csv
@@ -0,0 +1,30 @@
+1.0,1.3857901778452535,0.5646190476190476,0.7319606863224238,0.765,5.3305012
+2.0,0.5684313004583411,0.8217460317460317,0.6234791874559356,0.788,5.2476887
+3.0,0.4905831271718293,0.8504960317460317,0.5502137369610078,0.816,5.2780736
+4.0,0.44710641780490046,0.8622460317460316,0.507108308136985,0.832,5.2201623
+5.0,0.4161624196716421,0.8703710317460317,0.4754469754987524,0.842,5.2467271
+6.0,0.39267227948912486,0.8776230158730159,0.45065514359834485,0.852,5.271739
+7.0,0.37349778819948315,0.8845,0.43106228302258875,0.86,5.2507247
+8.0,0.356711273108282,0.89025,0.41305560320857815,0.865,5.2104277
+9.0,0.34185023249041585,0.8955,0.3962174178864686,0.872,5.2381525
+10.0,0.32823313299042106,0.900375,0.38054277523337965,0.88,5.2121785
+11.0,0.315491705100328,0.905125,0.36540667420176315,0.884,5.2152054
+12.0,0.30350796534296215,0.907625,0.3510384539143976,0.887,5.2359832
+13.0,0.2917294059179154,0.91175,0.33741215573419253,0.891,5.221409
+14.0,0.28007947703812774,0.915625,0.3256616885744949,0.895,5.2581459
+15.0,0.26903833372283736,0.918375,0.3134887826503533,0.9,5.2468317
+16.0,0.2582387839549893,0.923375,0.30257759818077407,0.904,5.2642078
+17.0,0.24793377312342682,0.925875,0.2921610039187919,0.907,5.2371349
+18.0,0.23819607204629348,0.928375,0.2823879693963766,0.911,5.2559867
+19.0,0.2292235461528336,0.93025,0.273400476950809,0.913,5.2403522
+20.0,0.2209457850898866,0.932,0.26516041908569515,0.919,5.2550661
+21.0,0.21332982834010106,0.934,0.2575876194732466,0.922,5.2385794
+22.0,0.20638915200434282,0.937,0.2505459867045295,0.924,5.2494052
+23.0,0.1999071823329033,0.939125,0.24401408966354393,0.927,5.2559466
+24.0,0.19397797659618402,0.94075,0.23809338594290166,0.93,5.2488361
+25.0,0.18852208615222923,0.94225,0.23228565192801962,0.932,5.2528026
+26.0,0.18348110558300604,0.9435,0.22721243789295575,0.932,5.2581057
+27.0,0.17885126807038831,0.944875,0.222421900563385,0.937,5.2454294
+28.0,0.17456385268716143,0.9465,0.21804989421618584,0.938,5.2457904
+29.0,0.17061639368361722,0.94775,0.21415673522380455,0.938,5.2492067
+30.0,0.166888384640409,0.948375,0.21049819306789677,0.939,5.2299216
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_mnist.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_mnist.csv.mtd
new file mode 100644
index 00000000000..63066fb27d2
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_diagonal_mnist.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 30,
+    "cols": 6,
+    "nnz": 180,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 08:29:18 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_mnist.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_mnist.csv
new file mode 100644
index 00000000000..e7d8ef60b0b
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_mnist.csv
@@ -0,0 +1,30 @@
+1.0,1.3968817437923011,0.5666170634920635,0.7109426273649633,0.772,5.5362371
+2.0,0.5422156218303953,0.8298710317460317,0.5874008650058562,0.805,5.2614495
+3.0,0.4580689644255494,0.8598710317460317,0.5135835359836203,0.835,5.3245232
+4.0,0.4085299529961879,0.8739960317460317,0.4629310510069232,0.847,5.2657728
+5.0,0.3744498144888525,0.8841230158730159,0.4294496771127414,0.858,5.3684353
+6.0,0.3482254212325919,0.89325,0.4016917288875425,0.87,5.2746683
+7.0,0.32644331573698165,0.90375,0.37816824036388574,0.876,5.3857298
+8.0,0.30740826477091837,0.9085,0.35889205504668836,0.883,5.3341332
+9.0,0.2899825260130954,0.912875,0.34101494981484803,0.884,5.3874481
+10.0,0.2738419712933966,0.917125,0.32457532313402715,0.892,5.3680929
+11.0,0.25908163407723,0.922,0.3100380303313327,0.902,5.3938413
+12.0,0.24576224893321097,0.924875,0.29742807859159387,0.906,5.414599
+13.0,0.23391526860320636,0.928375,0.285618762694352,0.908,5.3437024
+14.0,0.2232570085798237,0.932875,0.27529341934644824,0.911,5.4071808
+15.0,0.21367623660261073,0.934875,0.265642640592245,0.918,5.3577067
+16.0,0.20499424881583464,0.937125,0.25702880054693544,0.923,5.4244476
+17.0,0.19716216164849076,0.939125,0.248436394018528,0.923,5.3548261
+18.0,0.1900326773227678,0.940625,0.24069232408429253,0.925,5.4184062
+19.0,0.18354880745164945,0.942625,0.23356184493107382,0.926,5.3706423
+20.0,0.17760936986157816,0.944375,0.2271132659151866,0.927,5.3886075
+21.0,0.17219953170336277,0.946875,0.22097460735375044,0.929,5.416253
+22.0,0.1671937491912417,0.948625,0.21547076832387607,0.932,5.3531536
+23.0,0.16254762050040597,0.950125,0.21041945222651776,0.933,5.4161205
+24.0,0.1582729010416807,0.9515,0.20547421934126173,0.936,5.3464161
+25.0,0.15419864291613122,0.953,0.20102872883325873,0.939,5.3968156
+26.0,0.150414016123742,0.95375,0.19672941709454136,0.941,5.369739
+27.0,0.1468671893933918,0.955,0.19276066812411718,0.942,5.3666541
+28.0,0.14357153160959613,0.956375,0.18897210951490082,0.942,5.4230144
+29.0,0.14044228163921008,0.957,0.18539700571879691,0.945,5.3552148
+30.0,0.1375059791756444,0.9575,0.18214220693574806,0.945,5.3962925
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_mnist.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_mnist.csv.mtd
new file mode 100644
index 00000000000..1374abd380a
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_heuristic_mnist.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 30,
+    "cols": 6,
+    "nnz": 180,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 08:26:34 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_mnist.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_mnist.csv
new file mode 100644
index 00000000000..5ef28f355a9
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_mnist.csv
@@ -0,0 +1,30 @@
+1.0,1.0672269697519308,0.745,0.3154896337179667,0.894,6.8950551
+2.0,0.1912725967718522,0.939875,0.18994796911520165,0.937,6.4917396
+3.0,0.13750680303122417,0.95825,0.14552025052626202,0.95,6.7026874
+4.0,0.10600539294542247,0.968,0.12300881382807402,0.957,6.7345575
+5.0,0.0895785686951236,0.971625,0.1087237926245199,0.962,6.8608509
+6.0,0.07792385997209715,0.97525,0.0990134007840646,0.964,6.9115872
+7.0,0.06857964022931606,0.978875,0.09194584181372921,0.967,6.7975429
+8.0,0.06131704056989847,0.9805,0.08709034624278664,0.968,6.9278184
+9.0,0.055266330731975635,0.982375,0.08248557253423228,0.97,6.9246271
+10.0,0.0503285031091997,0.98475,0.07925273719721848,0.973,6.8895472
+11.0,0.045796471641668016,0.986,0.07626973107476949,0.976,6.9424098
+12.0,0.04195481785390929,0.986875,0.07509220297927882,0.976,6.9327283
+13.0,0.03867272959375796,0.987625,0.07379177486691342,0.975,6.9728977
+14.0,0.03572849416488416,0.988375,0.07317515100398074,0.976,6.9603044
+15.0,0.03302029851342425,0.989875,0.07340364612161045,0.979,6.9702403
+16.0,0.030738249568558456,0.990875,0.07289435577769543,0.978,7.011191
+17.0,0.028540951372596,0.991875,0.07266255568521712,0.98,7.0245984
+18.0,0.026634963373797713,0.99275,0.07305224689062484,0.98,7.0895
+19.0,0.02485411954746853,0.993375,0.07332345043231936,0.978,7.1151131
+20.0,0.023210141534566117,0.994125,0.07427359725206378,0.978,7.2813296
+21.0,0.021622792927153293,0.994875,0.07606467362568518,0.978,7.5442012
+22.0,0.02034490194481817,0.995,0.07589338531205875,0.978,7.2909892
+23.0,0.018977580908473558,0.99575,0.07610500912114254,0.977,7.2659957
+24.0,0.01769668843805958,0.996125,0.07613984192989082,0.977,7.2617284
+25.0,0.01648160390596983,0.996375,0.07555342763341072,0.977,7.2503283
+26.0,0.015396002311372663,0.99675,0.07494203073083414,0.977,7.1952044
+27.0,0.014465453072322028,0.99675,0.07375335675533735,0.978,7.3163035
+28.0,0.013468498837532962,0.99725,0.07278806802310099,0.978,7.328314
+29.0,0.01258707345631355,0.9975,0.07200631260885543,0.978,7.3445472
+30.0,0.011804466835341136,0.997875,0.07137613460647965,0.978,7.3730342
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_mnist.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_mnist.csv.mtd
new file mode 100644
index 00000000000..0672e6a5eb5
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_mnist.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 30,
+    "cols": 6,
+    "nnz": 180,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 08:13:44 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_cifar.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_cifar.csv
new file mode 100644
index 00000000000..d7b285690f7
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_cifar.csv
@@ -0,0 +1,200 @@
+1.0,2.264531363306536,0.17525,2.2524209891590146,0.136,15.1192633
+2.0,2.1036487981603926,0.209875,2.116105637732411,0.191,16.3926771
+3.0,2.0673184383279657,0.21875,2.0671178045527436,0.2095,15.7123529
+4.0,2.0206893951685068,0.247875,2.045779213051997,0.251,20.0922177
+5.0,1.97764013055239,0.26375,2.0122595373957104,0.2555,17.1218173
+6.0,1.9110808348664199,0.2935,1.8071641298339884,0.3345,16.8001048
+7.0,1.8373279193686338,0.329125,1.7384360651889805,0.3635,16.5603975
+8.0,1.7721336870687594,0.35925,1.6549900866813188,0.3995,14.9842052
+9.0,1.7284806405205346,0.374625,1.6424660309092987,0.4025,15.8602069
+10.0,1.6902372408532687,0.393875,1.568710661563789,0.428,15.6008094
+11.0,1.6633654757170033,0.3985,1.5891899754562873,0.4285,15.3528733
+12.0,1.6281171627735753,0.415375,1.5761536289863762,0.4345,15.0810408
+13.0,1.6241790499093782,0.412375,1.6957486992845836,0.3885,13.4078325
+14.0,1.5958414734531405,0.425,1.5789583560492217,0.4465,14.7857495
+15.0,1.5857690798780164,0.4315,1.5728320917913625,0.442,14.6559205
+16.0,1.5616704638698944,0.436,1.5732617778566487,0.4455,14.6416249
+17.0,1.567343323934309,0.43275,1.5417168289578709,0.453,13.3608869
+18.0,1.5459703241960894,0.443375,1.563004802215811,0.449,14.5187628
+19.0,1.5273336266738566,0.4515,1.5043120348145993,0.4645,14.4842276
+20.0,1.5147094180626144,0.451,1.4882037205512182,0.471,14.4512046
+21.0,1.4673836048435869,0.472375,1.452130933591962,0.4905,12.904708
+22.0,1.4655903102751024,0.469875,1.4605752210852259,0.48,14.4928238
+23.0,1.4619555365595454,0.478625,1.4484644897513659,0.49,14.6287528
+24.0,1.452639168121956,0.473625,1.4456110531273243,0.489,12.9840592
+25.0,1.4490949956464987,0.47675,1.4542072289626675,0.481,14.6030493
+26.0,1.443888470229089,0.473125,1.4430465220826345,0.494,14.6328587
+27.0,1.439330810640644,0.4785,1.4268997203677212,0.4935,14.6441291
+28.0,1.438276643229753,0.48225,1.4400235665218124,0.485,12.9043445
+29.0,1.4291816959216714,0.48525,1.424907154359232,0.4945,14.5867728
+30.0,1.4185051060646012,0.48325,1.3990301839259218,0.5,14.5967426
+31.0,1.4191328307261262,0.491,1.4284329551595496,0.494,12.9537765
+32.0,1.4199606614381441,0.487,1.422892406019973,0.498,14.55842
+33.0,1.4031712674318453,0.4935,1.4130693571829114,0.496,14.5796997
+34.0,1.4048654394719795,0.497875,1.4158720643019476,0.497,14.6541082
+35.0,1.4028745586530076,0.4945,1.3968087234441189,0.499,13.6315132
+36.0,1.3923774848700783,0.496625,1.4041774976596844,0.503,16.7142031
+37.0,1.3872566161026847,0.50125,1.38917197016695,0.5065,16.383204
+38.0,1.378412535460756,0.5065,1.4050737260773256,0.5045,14.6910836
+39.0,1.3786045281688108,0.5055,1.3895179012495684,0.5065,15.0160016
+40.0,1.3804915273249434,0.499375,1.4009439596465,0.496,15.2889884
+41.0,1.3709136595868627,0.509625,1.3720189037229937,0.5045,16.2083134
+42.0,1.3644766958907186,0.512875,1.366914430419465,0.5095,14.0672407
+43.0,1.3663732941302456,0.508,1.3660117725603969,0.519,15.231735
+44.0,1.3501037832767524,0.513125,1.3696464767009164,0.5105,15.234361
+45.0,1.3543506136918446,0.515375,1.365825435684687,0.513,13.8195529
+46.0,1.3590577601242946,0.516375,1.3655506231957335,0.512,15.7402211
+47.0,1.353690261687157,0.51225,1.3649695233038823,0.514,15.8925841
+48.0,1.3639233496841165,0.50875,1.3624995782440876,0.512,13.7750749
+49.0,1.3368925007185397,0.519375,1.3588574953836818,0.5135,15.288518
+50.0,1.3363157937213859,0.51925,1.3565843837375187,0.5175,15.6729901
+51.0,1.337341284925157,0.522875,1.3624873241966318,0.5155,13.4714207
+52.0,1.3347898479097353,0.521375,1.357563852923182,0.5155,15.6345323
+53.0,1.3388240010485097,0.515375,1.3518248735852874,0.5145,15.9921757
+54.0,1.3282962813099992,0.529625,1.3595476251946146,0.514,13.803205
+55.0,1.3445866882333266,0.51725,1.3651002703473858,0.5035,14.9594587
+56.0,1.3377694569703154,0.521125,1.3565238057370486,0.515,14.9381128
+57.0,1.3297816020027813,0.52375,1.3503421153705923,0.5125,13.8143254
+58.0,1.3219488155287928,0.5235,1.351774773183257,0.5135,15.4137554
+59.0,1.3265562295382303,0.52675,1.354513369222431,0.5175,16.0579631
+60.0,1.3312265943618973,0.52325,1.3524720831070618,0.516,14.2554182
+61.0,1.3272178009201925,0.523875,1.3533551356165001,0.517,16.5495722
+62.0,1.3236307611456566,0.52225,1.3507945299332174,0.5155,15.7370495
+63.0,1.3253751338232214,0.514875,1.3478426546084752,0.516,13.4004035
+64.0,1.3167046599698915,0.527875,1.3481887501247534,0.5205,14.9484908
+65.0,1.3150668925319913,0.528375,1.3482548752501837,0.516,15.7404474
+66.0,1.3212383370218517,0.524875,1.346726240590312,0.515,14.4361898
+67.0,1.3204936176451465,0.5285,1.3487230940882973,0.515,16.0911403
+68.0,1.310422387927823,0.52925,1.347837421228968,0.5175,15.5049029
+69.0,1.3329962450791217,0.521125,1.3470429745764512,0.518,14.3225444
+70.0,1.3071627232145697,0.529625,1.3442955184798917,0.518,15.2111932
+71.0,1.2996784295378554,0.532625,1.3446045859712306,0.5215,16.206452
+72.0,1.3041435018356875,0.538375,1.3463207004736852,0.516,13.9512571
+73.0,1.3117658652715567,0.52575,1.3454812070693083,0.5175,16.017497
+74.0,1.309219960022251,0.531875,1.346387597365895,0.5155,16.0621942
+75.0,1.313202685332761,0.52725,1.3442610680054343,0.519,14.4096378
+76.0,1.3127296629859724,0.529125,1.3422821573010555,0.5195,16.2684382
+77.0,1.3088257320135446,0.528875,1.3446410056685385,0.513,16.1698006
+78.0,1.3070981878854082,0.5285,1.3420348329163059,0.5175,14.3655351
+79.0,1.3102636495288122,0.5315,1.343603039042454,0.518,16.2607702
+80.0,1.3028561158995375,0.536375,1.3424362608029832,0.519,16.0204513
+81.0,1.3007630027712558,0.53575,1.3398355325193145,0.521,14.5797663
+82.0,1.3134073802575998,0.534875,1.3416543719171308,0.519,16.2121146
+83.0,1.3059576184223014,0.52925,1.3399359247727363,0.522,16.2911817
+84.0,1.3047267869111328,0.52775,1.340288187093933,0.523,14.0880504
+85.0,1.2835015840061434,0.536875,1.339292322044208,0.521,16.2294541
+86.0,1.3027022357710711,0.53025,1.338068561547965,0.523,15.274938
+87.0,1.2894236325012223,0.534,1.3395109845010853,0.5205,14.2536689
+88.0,1.3027552245659266,0.52925,1.3390355031863295,0.519,16.2064674
+89.0,1.314820046532236,0.528125,1.339397137745383,0.52,16.0111338
+90.0,1.2969517512996491,0.5375,1.3378503233559176,0.5245,14.220893
+91.0,1.3032467766868938,0.53475,1.3380473610470531,0.521,16.0427978
+92.0,1.3020578520699047,0.534375,1.337908818371762,0.522,15.7429323
+93.0,1.2921965984934127,0.535875,1.3389740429370327,0.519,14.3099935
+94.0,1.3049342748053159,0.534,1.3389500611094294,0.5215,15.1546298
+95.0,1.2869172680524168,0.53975,1.3377752598802848,0.5225,16.0374185
+96.0,1.2892105427249119,0.53225,1.337303638711213,0.522,14.8088073
+97.0,1.3015571876516687,0.537125,1.3383695642561324,0.52,16.4182009
+98.0,1.3002865268480472,0.5315,1.3366133159704687,0.521,16.3854835
+99.0,1.2845867329782805,0.537625,1.3370824295445132,0.524,15.7797019
+100.0,1.2959321335635203,0.538625,1.3359542455340458,0.522,15.9973989
+101.0,1.2921367026971824,0.542875,1.33516581524642,0.5245,16.1556855
+102.0,1.3012235312277562,0.52975,1.3358909481369263,0.524,14.3586786
+103.0,1.2848732553600015,0.54025,1.3346965165481333,0.5235,16.2865366
+104.0,1.2911549604913042,0.5415,1.335535143232428,0.522,16.2141815
+105.0,1.28035494690788,0.543,1.3353588392887596,0.5215,13.6648141
+106.0,1.2924818700935368,0.536125,1.3368862319774608,0.5215,15.9270246
+107.0,1.2904330481478798,0.535625,1.3358733571592842,0.5225,16.213704
+108.0,1.292712732753748,0.536,1.3346608752502658,0.524,14.1965963
+109.0,1.2780086918498348,0.5405,1.3349210912469138,0.5245,16.1199759
+110.0,1.2879306301212579,0.5365,1.3341388994530403,0.523,15.745916
+111.0,1.3022143023268191,0.536,1.334916362080222,0.523,13.9348722
+112.0,1.2879041052322764,0.53925,1.3350402207538645,0.522,15.6203761
+113.0,1.2851197665531398,0.541125,1.3348180476716311,0.5235,15.2566172
+114.0,1.2808228990590773,0.544875,1.33427858116211,0.5225,13.9109513
+115.0,1.2862879264071587,0.537875,1.3341600493293166,0.525,16.2575684
+116.0,1.2897378844187386,0.540625,1.3345218764580584,0.522,16.2005281
+117.0,1.2863680863584062,0.5405,1.3346601122804047,0.522,14.1893536
+118.0,1.295472390493655,0.540875,1.3336387075807161,0.5225,16.0611998
+119.0,1.294368435606113,0.533875,1.3337353839817345,0.5225,15.8792932
+120.0,1.2916438892564652,0.536875,1.3342602990004797,0.521,14.0947471
+121.0,1.289313781130236,0.53725,1.3339817012534936,0.5215,15.3446459
+122.0,1.2806683445400495,0.542375,1.3344297678579964,0.522,15.7714217
+123.0,1.2935331175264637,0.534625,1.3340954806941063,0.521,14.659198
+124.0,1.293726096618768,0.539125,1.334356401031101,0.523,15.8610345
+125.0,1.2889151206884653,0.53325,1.3343659406094,0.521,16.0753105
+126.0,1.286142135667246,0.538375,1.3339063175720378,0.5245,14.3024143
+127.0,1.2891570727706043,0.539375,1.3339737428410479,0.5245,16.0072251
+128.0,1.2951245790345738,0.535625,1.3342535409792609,0.5255,15.8702727
+129.0,1.2958280449662474,0.542875,1.3346272629010643,0.523,13.8500479
+130.0,1.2820414364036996,0.539,1.3340152937015917,0.524,15.6921369
+131.0,1.293762990584683,0.535625,1.3336577925917428,0.524,16.0344213
+132.0,1.2983325279674265,0.5315,1.3337345533416305,0.5235,14.1520503
+133.0,1.2870033580327678,0.538375,1.3335127198244459,0.524,16.2214209
+134.0,1.2889157501200066,0.537625,1.3333061161102449,0.5235,16.4031728
+135.0,1.2886114766265373,0.535625,1.3337254259803533,0.5215,13.8848493
+136.0,1.2939695034136753,0.535125,1.3341858223545073,0.524,16.7677424
+137.0,1.2950125452394161,0.525875,1.3340652120332983,0.5225,15.289456
+138.0,1.283786827161245,0.546375,1.3337751567905312,0.523,14.071376
+139.0,1.2805583985666478,0.53825,1.3334550636180937,0.523,16.01665
+140.0,1.2937217986088576,0.53225,1.3335698796317401,0.5205,16.1573857
+141.0,1.2912754327389204,0.537875,1.3336561061519638,0.5205,14.2628154
+142.0,1.2929130884983318,0.534625,1.3338549771168016,0.521,15.9366074
+143.0,1.2838901961015974,0.53825,1.3336869759204875,0.521,15.1808514
+144.0,1.287138291174084,0.540125,1.3334967722543458,0.5215,14.1995845
+145.0,1.2856155827077795,0.533,1.3333403323550044,0.522,16.0970121
+146.0,1.2946832133632542,0.5395,1.3334058988367772,0.5225,15.8439865
+147.0,1.2758869662215424,0.542625,1.3332129423095724,0.5225,14.0033164
+148.0,1.2909422990768142,0.537375,1.3332671641542695,0.524,15.8590276
+149.0,1.2836525777523138,0.543875,1.3333441600657678,0.524,16.3236664
+150.0,1.2882770829546208,0.539125,1.333568668532656,0.5235,14.2852665
+151.0,1.28589908136827,0.540625,1.3334725951835673,0.523,15.9381744
+152.0,1.2825370639575737,0.540125,1.3334763530633857,0.523,15.4325727
+153.0,1.2842598514754808,0.53975,1.3333864950658108,0.5235,14.1405752
+154.0,1.2855673499068023,0.543375,1.3331826815659498,0.523,15.4006675
+155.0,1.2796685507143122,0.5415,1.3330995934433378,0.5235,16.0489669
+156.0,1.290990778769658,0.54,1.333156108596848,0.524,14.4498774
+157.0,1.2949980807144286,0.53425,1.3335114230071825,0.522,15.2942715
+158.0,1.2935658819225175,0.538,1.3335606470214256,0.523,14.9612473
+159.0,1.2834168916074506,0.5395,1.3335287949636743,0.5225,13.4138468
+160.0,1.296543034776782,0.535375,1.333737736584474,0.5235,14.9465464
+161.0,1.2899502968686272,0.534125,1.3335085777430096,0.524,14.999506
+162.0,1.2972334615899725,0.53325,1.3335426897378415,0.5225,13.338925
+163.0,1.2873149534945814,0.535,1.3333769321550852,0.5215,14.8673685
+164.0,1.2851488515887488,0.536,1.3332288139853783,0.5225,14.9184405
+165.0,1.2830425022188514,0.545125,1.3334076888951572,0.5225,13.3890631
+166.0,1.286687135851395,0.540125,1.3334718578168638,0.522,14.9619712
+167.0,1.2868045200466687,0.54025,1.3334500023116105,0.5225,14.9980383
+168.0,1.2947535000420507,0.531625,1.3335005293396933,0.523,13.3628698
+169.0,1.292758856119712,0.533625,1.3335703985178562,0.523,15.0637834
+170.0,1.2983691461121052,0.538375,1.3334344857788534,0.5225,14.9735214
+171.0,1.289527062409313,0.534375,1.3334033251743733,0.522,13.4100774
+172.0,1.3003175776723468,0.53225,1.333322809469281,0.5235,15.0178233
+173.0,1.2873977064134468,0.539875,1.333385359365248,0.5235,14.9874359
+174.0,1.2912027145687395,0.534125,1.333281408885529,0.5235,13.3680556
+175.0,1.2857499792552782,0.5395,1.3332893523934572,0.524,14.8997864
+176.0,1.2952536463807691,0.535625,1.333267411007877,0.5235,14.986912
+177.0,1.2934431431671598,0.538,1.3332286427403264,0.5235,13.3794938
+178.0,1.2814326227915276,0.538125,1.3331327377305882,0.523,14.945538
+179.0,1.2822530365926654,0.543375,1.33310288950039,0.5235,14.9358134
+180.0,1.2865291845758648,0.537125,1.3330728602747466,0.5235,13.4063317
+181.0,1.30013264712133,0.53525,1.3330393670563834,0.5235,15.0042163
+182.0,1.2846878344323702,0.542375,1.3329867365498702,0.523,14.9085367
+183.0,1.2885621727392367,0.547375,1.3330173184484886,0.5225,13.4352478
+184.0,1.2782688624893286,0.54775,1.333030368499129,0.522,14.9053492
+185.0,1.2817435934018753,0.540625,1.332988076168602,0.5225,14.9291116
+186.0,1.289142721196581,0.539875,1.3330034919907876,0.522,13.4718049
+187.0,1.2855187500130607,0.5405,1.3329439350244259,0.522,14.9128477
+188.0,1.2976619422131532,0.534875,1.3328755163666313,0.522,14.9392618
+189.0,1.2910918442304136,0.5425,1.3328346289984203,0.5225,13.3626048
+190.0,1.302245583561614,0.529375,1.3328751383699933,0.522,14.9435189
+191.0,1.281956422633208,0.535625,1.3328262730547544,0.522,14.9694986
+192.0,1.2875774740690604,0.541375,1.3328226506532501,0.5225,13.3329662
+193.0,1.2993898158690094,0.534,1.3328685771029491,0.5225,14.9577163
+194.0,1.2877930161069044,0.538875,1.3328580032329884,0.5225,14.9177301
+195.0,1.2866413280922961,0.5355,1.3329425604660379,0.522,13.3912778
+196.0,1.2894215967969298,0.539625,1.3328986911022078,0.5215,14.9634809
+197.0,1.2818862197927154,0.5375,1.332957556219699,0.5225,14.9664049
+198.0,1.289979329334987,0.5365,1.333012498285308,0.5225,13.4005485
+199.0,1.2966938574299653,0.5345,1.3329807949430375,0.522,14.8990188
+200.0,1.2832790991395928,0.539625,1.3329844298134985,0.522,15.2311098
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_cifar.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_cifar.csv.mtd
new file mode 100644
index 00000000000..613f736b101
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_cifar.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 200,
+    "cols": 6,
+    "nnz": 1200,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-15 15:40:15 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_cifar.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_cifar.csv
new file mode 100644
index 00000000000..e6aa47668c4
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_cifar.csv
@@ -0,0 +1,200 @@
+1.0,2.3157880689928874,0.143,2.266711392098975,0.1275,12.5512191
+2.0,2.1409819745452863,0.196875,2.106326467963478,0.2145,10.9266592
+3.0,2.079099223017421,0.21925,1.9766032064628472,0.258,11.1126151
+4.0,1.9894474886042735,0.2685,1.9605719971143494,0.2845,11.6153142
+5.0,1.9445644817807013,0.288375,1.945481640781369,0.307,12.2193038
+6.0,1.8741544326569886,0.332,1.7728359754282186,0.357,11.138006
+7.0,1.848646059909481,0.328625,1.8563254439547625,0.3205,10.4724669
+8.0,1.8112829336610905,0.34225,1.7085865568144627,0.3885,10.0896784
+9.0,1.7862062127325131,0.354125,1.7231854470642987,0.379,9.8884766
+10.0,1.7615489164606373,0.3585,1.6706740558799607,0.3995,9.3439085
+11.0,1.741095913727558,0.36075,1.6685849942200963,0.3845,9.1406507
+12.0,1.7260942725161812,0.3725,1.6836035145344073,0.3825,9.0319209
+13.0,1.7103223143744306,0.38075,1.6252963535989209,0.413,8.929766
+14.0,1.6721708030090296,0.392875,1.579800951716784,0.425,8.7924606
+15.0,1.6552514567223222,0.40175,1.6093665378393254,0.4165,8.7071949
+16.0,1.636435211516211,0.409,1.530321263519919,0.447,8.6658207
+17.0,1.6154527388112714,0.41675,1.5474830096809555,0.445,11.47643
+18.0,1.6232995004256194,0.423875,1.58858502932433,0.4305,13.7200089
+19.0,1.6143557396827017,0.417625,1.5431519693269369,0.454,13.6679685
+20.0,1.5850691889947872,0.42925,1.54828877967272,0.4565,11.5349927
+21.0,1.5467506125070962,0.450875,1.530231503936324,0.4615,13.7097609
+22.0,1.5305861092354516,0.44625,1.5043873242759405,0.469,13.4003398
+23.0,1.5184436049294818,0.450625,1.4902141195062713,0.465,11.4745623
+24.0,1.525958265380638,0.451125,1.4919576338072948,0.4565,13.7305429
+25.0,1.5118629035459226,0.458125,1.4779299883721067,0.4735,13.6704117
+26.0,1.5035068279722636,0.4625,1.4716430900419533,0.475,11.9292932
+27.0,1.493542350279005,0.4625,1.4599315157446644,0.475,13.6995191
+28.0,1.4878278914316323,0.46475,1.5048545357123067,0.4645,13.9638124
+29.0,1.486186755563834,0.462,1.4805201952959401,0.4715,11.6843123
+30.0,1.4752773511419017,0.464375,1.454878589808295,0.483,14.1432484
+31.0,1.466371030567353,0.47175,1.437423002759957,0.4895,13.9879232
+32.0,1.4722916539802005,0.47225,1.4698879134985634,0.479,12.1209128
+33.0,1.4582535100579879,0.476875,1.4514096707219666,0.4825,13.7909428
+34.0,1.4665625864076923,0.476125,1.4513490951624788,0.475,13.7060217
+35.0,1.450695571252721,0.47525,1.4593336607735035,0.484,11.975205
+36.0,1.4495146613839205,0.4835,1.44873788506632,0.479,13.3180128
+37.0,1.438413299803386,0.483,1.4368662250583573,0.484,13.2186843
+38.0,1.43207925982626,0.490375,1.457708896792147,0.4785,11.3311222
+39.0,1.436544235902102,0.483875,1.443137550599694,0.481,13.2581312
+40.0,1.4291147348879263,0.49125,1.4548008740354403,0.48,13.2651795
+41.0,1.4177326880844603,0.49675,1.385246427821156,0.502,11.7076944
+42.0,1.4135705231281257,0.4885,1.3986385495675402,0.4995,14.0297879
+43.0,1.4058895944503582,0.496875,1.4039026083109798,0.4995,12.0711571
+44.0,1.4119846640413494,0.495625,1.3971678877623277,0.505,13.9127872
+45.0,1.4028407512333612,0.497125,1.3785696960176375,0.508,12.1862109
+46.0,1.3949695773459159,0.491625,1.3836750487252991,0.5085,14.4667225
+47.0,1.411741215237472,0.489,1.4010050066701447,0.5025,12.1904013
+48.0,1.3980950882818226,0.50125,1.3918663084512155,0.5035,14.175029
+49.0,1.393821381727539,0.504,1.3838073639729,0.5085,11.9950756
+50.0,1.3894921368446513,0.50025,1.3899047800459923,0.508,13.8684372
+51.0,1.3965245260528532,0.493,1.3844490079518912,0.5085,11.8604857
+52.0,1.3793064160984645,0.51,1.383454716550735,0.5045,14.1109849
+53.0,1.3912244383153525,0.502,1.3754343884224494,0.5085,12.0991638
+54.0,1.3785888563322664,0.503125,1.3748788155029616,0.508,14.3859225
+55.0,1.3762015227068793,0.508625,1.3830224900200274,0.511,11.9410074
+56.0,1.3655160462991154,0.508875,1.3725258879549327,0.516,13.7040802
+57.0,1.3744411907004717,0.5085,1.3795354180139374,0.515,12.0146637
+58.0,1.3718616371840904,0.51225,1.3785682558754342,0.5105,14.0311921
+59.0,1.3814933339669948,0.506375,1.3696816259709597,0.5155,12.1441999
+60.0,1.3690715952399044,0.514875,1.3759583121264691,0.512,14.1361634
+61.0,1.3511693044388786,0.511625,1.3583146517846747,0.513,11.9490806
+62.0,1.369119600963849,0.508375,1.3608122424854772,0.5155,14.1257241
+63.0,1.3553416577524002,0.51775,1.3602560609339485,0.517,12.1039484
+64.0,1.3675879828941189,0.5155,1.3586298557307157,0.519,14.4321177
+65.0,1.3554543194852524,0.515125,1.3587258876617896,0.515,12.2327826
+66.0,1.3602361854034586,0.51775,1.3567784524343074,0.513,14.5178849
+67.0,1.3580991534821787,0.51325,1.361254655098313,0.515,12.8226197
+68.0,1.3564725659127264,0.511375,1.3567669420025505,0.5175,14.3373823
+69.0,1.367403085025942,0.506625,1.3577766821789408,0.515,12.5606728
+70.0,1.3516890530383963,0.514125,1.3572058348669185,0.5185,14.5696158
+71.0,1.3546194877970033,0.51275,1.3559996188382946,0.5145,12.7672584
+72.0,1.3488886076940074,0.521375,1.3547158656296738,0.516,14.5743038
+73.0,1.3473020072496498,0.517125,1.351236398951223,0.5145,11.8103545
+74.0,1.3510353409669316,0.515375,1.3552412362003086,0.519,13.7639647
+75.0,1.3512073115118657,0.51775,1.3545110652482681,0.5155,11.6222744
+76.0,1.347657641397583,0.520625,1.3522552871224227,0.5155,14.2112879
+77.0,1.347567496322903,0.517625,1.352590562383749,0.515,12.0969011
+78.0,1.3492111530254784,0.5145,1.3522919773902298,0.5135,13.9660561
+79.0,1.3401332939050763,0.516,1.3520117421246431,0.516,12.4209539
+80.0,1.341666778779767,0.512,1.3484608878899849,0.52,14.2447223
+81.0,1.3388053039809567,0.522375,1.349975786956574,0.5185,12.1933038
+82.0,1.3248273774884733,0.524375,1.3491935964203958,0.523,13.9520394
+83.0,1.3372436796152822,0.524125,1.3480744632813892,0.518,12.6271241
+84.0,1.3448557224242477,0.5175,1.3505950716925101,0.5175,14.6230825
+85.0,1.3290038732568863,0.52825,1.3482386006512708,0.518,12.0987562
+86.0,1.3391579167758731,0.525625,1.3466445351311933,0.521,14.1919864
+87.0,1.3325859716721962,0.519125,1.3489327377440552,0.5175,11.7293726
+88.0,1.333540532434537,0.525625,1.3470617320016176,0.5215,14.2790142
+89.0,1.3524335548471744,0.511125,1.3478045876405493,0.5195,12.5790056
+90.0,1.3306246466736955,0.527625,1.3438939046783587,0.522,13.9712426
+91.0,1.343057271047558,0.522125,1.3469285098402757,0.5195,11.9473189
+92.0,1.3312068016889718,0.52725,1.3465891326274995,0.5155,13.6411942
+93.0,1.330688667544318,0.523,1.348229550840398,0.5185,11.7721963
+94.0,1.325353026497771,0.52725,1.3482617434104855,0.5205,13.4833187
+95.0,1.334649252471791,0.5185,1.3468837036891863,0.5175,12.2106954
+96.0,1.3347302287769565,0.5195,1.3466383478838755,0.519,14.0990139
+97.0,1.313097860721014,0.53,1.3452729166805197,0.521,11.9987866
+98.0,1.3310380545459513,0.53075,1.3479693707241243,0.5195,13.9081747
+99.0,1.329073769717886,0.53275,1.34659769937679,0.52,12.2095898
+100.0,1.3213308498674283,0.5205,1.3448444469219192,0.5175,14.2702717
+101.0,1.33469093310411,0.5235,1.345583369999924,0.5205,12.1985062
+102.0,1.3332826994106683,0.5235,1.3448925537348078,0.521,14.1301378
+103.0,1.3269464727996603,0.519625,1.34440216379681,0.5225,12.2085062
+104.0,1.3328728178672153,0.518875,1.3448144422684594,0.523,13.5566751
+105.0,1.333911003336845,0.524625,1.3437538105734677,0.5235,11.9244457
+106.0,1.3300348105199205,0.5275,1.344800059518195,0.5215,14.2653785
+107.0,1.325329527314247,0.525375,1.342851655576912,0.5225,12.6552612
+108.0,1.3127596317524333,0.530125,1.3443464685730993,0.5225,14.0137707
+109.0,1.3249476456714924,0.527875,1.3442383624245526,0.5215,12.507873
+110.0,1.3260743342758279,0.532,1.3437622853568998,0.5235,13.9881505
+111.0,1.3184990213319925,0.534,1.3427849469315394,0.5225,12.3655972
+112.0,1.3266201589657443,0.524375,1.343874886864482,0.5245,14.5072942
+113.0,1.3281433831168181,0.529625,1.343742851633507,0.5245,12.2880757
+114.0,1.3304171460684249,0.525375,1.342382895268418,0.5215,14.6972253
+115.0,1.3157801355260865,0.52725,1.3415339890685438,0.5245,11.7250201
+116.0,1.3227598303731074,0.531625,1.3428817799840658,0.5215,13.6256107
+117.0,1.3288785467620008,0.524125,1.3439005136897915,0.521,11.8930585
+118.0,1.3304828197003238,0.515875,1.3438291198335433,0.524,13.6179918
+119.0,1.320879491367843,0.52575,1.3420942762905566,0.5225,11.7203504
+120.0,1.3233530557362179,0.52225,1.343671050663574,0.5205,13.5814375
+121.0,1.3279785538380084,0.52025,1.3431729206595784,0.521,11.713864
+122.0,1.3300042015120073,0.5275,1.342610016533775,0.52,13.5257199
+123.0,1.3352865531931173,0.52625,1.3430338918012255,0.5215,11.6806667
+124.0,1.3335295140875163,0.52425,1.342829839570433,0.521,13.5821248
+125.0,1.3133556520215304,0.533,1.3419767338348298,0.523,11.675267
+126.0,1.315430291800771,0.52825,1.3415590454691197,0.5215,13.5700286
+127.0,1.3210771695976777,0.525375,1.3417774801359468,0.5225,11.6689644
+128.0,1.3091244298523645,0.533,1.3420268998197868,0.522,13.562454
+129.0,1.312787960887864,0.53175,1.3420268485243139,0.5215,11.6587314
+130.0,1.3177353019258728,0.528125,1.3422115187901804,0.523,13.5619759
+131.0,1.3158628785913244,0.524,1.3417076484847141,0.5215,11.7852028
+132.0,1.3206504642614116,0.529875,1.3413260603598482,0.5235,13.5756216
+133.0,1.3221328060291435,0.52725,1.3416256816810885,0.525,11.7322522
+134.0,1.318477307628622,0.5225,1.3419321095461603,0.524,13.619538
+135.0,1.3029324136019587,0.534125,1.3413873293242742,0.5245,11.6802499
+136.0,1.320664447452476,0.526125,1.342561311547229,0.522,13.5487977
+137.0,1.3194386842744847,0.5305,1.3416685474204788,0.5205,11.733151
+138.0,1.31776901257688,0.536375,1.3419333257483705,0.5205,13.661361
+139.0,1.3161809297053153,0.528125,1.3417633471804291,0.519,11.7107709
+140.0,1.3277395031858796,0.522875,1.3416425003868109,0.5205,14.1153315
+141.0,1.3151062080340645,0.536,1.34148044792132,0.521,12.8290446
+142.0,1.3134652301440348,0.527625,1.3412867615049278,0.5215,14.2895394
+143.0,1.309437372013916,0.5325,1.341450662395274,0.5215,12.3450018
+144.0,1.3146498174430659,0.526875,1.3418809577374815,0.522,13.775643
+145.0,1.3230842496135176,0.522125,1.3418493171206105,0.5215,11.9432078
+146.0,1.3131875338895922,0.529625,1.3415062085585887,0.5225,14.5174607
+147.0,1.3113119887744038,0.52525,1.3412598046936655,0.5225,12.8940764
+148.0,1.3215377276593487,0.524,1.3412662776463833,0.5215,15.0257364
+149.0,1.324192619865555,0.526,1.3410356279461473,0.521,12.94243
+150.0,1.3303721754527122,0.52475,1.3412016127588178,0.521,14.4305974
+151.0,1.3200638396637712,0.527125,1.3412067965858954,0.522,12.5709783
+152.0,1.3223024032975392,0.524,1.3406070703088209,0.5215,14.0955406
+153.0,1.3191098008777513,0.5255,1.3409337693594157,0.521,12.236799
+154.0,1.3129426417184222,0.529875,1.3410091962326587,0.523,14.2121331
+155.0,1.309660375194985,0.5345,1.3408431892084285,0.523,12.5007225
+156.0,1.3185716122015687,0.527125,1.341238890734191,0.522,13.8466564
+157.0,1.3161287628572507,0.523375,1.3409632232569868,0.523,12.2410079
+158.0,1.3150509062672533,0.53525,1.3406892944464737,0.5225,14.0827358
+159.0,1.3152685836102556,0.52925,1.340450986063101,0.523,12.2373319
+160.0,1.3155766352012161,0.528375,1.3405906518613617,0.5235,14.0598233
+161.0,1.3171416982941289,0.531125,1.3406664604447769,0.524,11.7966045
+162.0,1.3197602197388536,0.532,1.3404663179008949,0.524,14.8789301
+163.0,1.324298230778107,0.52825,1.340798382996611,0.5235,12.0232858
+164.0,1.3130791580862005,0.529875,1.3406465881266896,0.524,14.2144681
+165.0,1.3208513289910915,0.530875,1.3404496190079584,0.5245,11.7574811
+166.0,1.3147169417064004,0.52525,1.3404223347433593,0.524,13.4994703
+167.0,1.3166377741345037,0.531125,1.3403726076844615,0.5245,11.6442875
+168.0,1.302881980387253,0.536375,1.340462914272213,0.5235,13.4665771
+169.0,1.3272969152354728,0.528375,1.3404052181120096,0.5235,11.6643696
+170.0,1.3249953208668348,0.532125,1.3403862511062463,0.523,13.5083491
+171.0,1.3153214205434764,0.5265,1.340321607689278,0.523,11.717446
+172.0,1.3319853556938892,0.517875,1.3403944159424492,0.5225,13.5085742
+173.0,1.315938898086998,0.52725,1.3404756415832242,0.522,11.6680136
+174.0,1.305554324193872,0.533625,1.340538669090909,0.522,13.5101024
+175.0,1.3199507807303574,0.52575,1.3406348358933875,0.521,11.8448283
+176.0,1.3183324463870947,0.52775,1.3406494082201688,0.5215,13.4840556
+177.0,1.3200154898498262,0.531375,1.3405232179816833,0.5225,11.6985986
+178.0,1.3133752651013222,0.5315,1.3407556553428666,0.522,13.4977775
+179.0,1.309817393760107,0.531875,1.3406614563065014,0.523,11.6820506
+180.0,1.3218945142923948,0.52,1.3406890710751735,0.5225,13.4991202
+181.0,1.3120463466833536,0.524,1.340732918790988,0.5225,11.6961718
+182.0,1.3167799368511601,0.527125,1.340619658962076,0.522,13.5140914
+183.0,1.3248430874405288,0.532,1.3406548647913514,0.523,11.6890105
+184.0,1.3193697140498652,0.5285,1.3406919833088806,0.522,13.5429234
+185.0,1.3250933054110374,0.527625,1.34068048042159,0.522,11.6562704
+186.0,1.3126481632286724,0.532125,1.3406019047998974,0.522,13.5153837
+187.0,1.3146314728215243,0.52925,1.340617869157852,0.522,11.6739261
+188.0,1.3142194156631846,0.530375,1.3405852234582374,0.5225,13.5246301
+189.0,1.3215610128375568,0.530125,1.3404874539145364,0.523,11.8664486
+190.0,1.326462378283354,0.52775,1.3405475052774876,0.5235,13.499073
+191.0,1.3305110780936578,0.524625,1.3405806878155055,0.523,11.6469098
+192.0,1.316585812386334,0.528,1.3406750540685948,0.522,13.5231797
+193.0,1.3186661330526908,0.529,1.3406830567415318,0.5225,11.6744253
+194.0,1.322304835448128,0.5265,1.340679303384344,0.522,13.537015
+195.0,1.3243337522325833,0.521375,1.3406954268334283,0.5215,11.6234184
+196.0,1.3228529680705647,0.5235,1.3406564390141442,0.522,13.4622592
+197.0,1.3139426454708887,0.53075,1.3406314443903489,0.5225,11.6568131
+198.0,1.328395719279288,0.527125,1.34073207610222,0.522,13.6241351
+199.0,1.3236769528367731,0.5235,1.340690663839012,0.5225,11.6782654
+200.0,1.3178963451283567,0.53075,1.3406611411712133,0.522,13.4969919
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_cifar.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_cifar.csv.mtd
new file mode 100644
index 00000000000..30bf87657b5
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_cifar.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 200,
+    "cols": 6,
+    "nnz": 1200,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 10:17:58 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_mnist.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_mnist.csv
new file mode 100644
index 00000000000..97276a2f9cd
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_mnist.csv
@@ -0,0 +1,30 @@
+1.0,0.6399534778455417,0.807625,0.4414916285930395,0.875,6.5675493
+2.0,0.2103697243179471,0.939125,0.18546637339458957,0.938,5.6294108
+3.0,0.15145646907937396,0.95475,0.15296044687215252,0.944,5.8055184
+4.0,0.12328296319322866,0.962875,0.14405190386327257,0.961,5.835223
+5.0,0.09868712245474252,0.969375,0.1576193063351126,0.961,5.9725667
+6.0,0.08105159147368214,0.976375,0.13470007074981435,0.957,6.0797144
+7.0,0.07030207597406542,0.979,0.1375097662041591,0.96,6.1848833
+8.0,0.06414214398281054,0.98125,0.137570296006365,0.959,6.2411967
+9.0,0.05898597849079802,0.983,0.13739588235627417,0.965,6.2468008
+10.0,0.054376928708701415,0.983625,0.13455704586363032,0.964,6.2073465
+11.0,0.048916195975170114,0.985,0.1310063648711662,0.962,6.3084106
+12.0,0.04394026131760645,0.98625,0.12785295041227956,0.965,6.276783
+13.0,0.0398092032702973,0.98775,0.1239035508490495,0.964,6.3689285
+14.0,0.0357282678114975,0.989625,0.11820593654418088,0.967,6.3784001
+15.0,0.03254369330103688,0.990625,0.11415661501697245,0.968,6.3398109
+16.0,0.029824099509760914,0.991375,0.10879177841703187,0.969,6.5956139
+17.0,0.027110994551449913,0.992375,0.10512890802301399,0.971,6.5646396
+18.0,0.0245529051263536,0.99325,0.10074488440711184,0.973,6.6188438
+19.0,0.02243487181821926,0.994,0.09817456434044222,0.973,6.6698722
+20.0,0.020763546550039782,0.995,0.09637982285157341,0.975,6.6068259
+21.0,0.01918025078649027,0.995625,0.09601095696043747,0.973,6.7624415
+22.0,0.018048087733333898,0.995625,0.0965307092801049,0.973,6.7299449
+23.0,0.017234113859355332,0.995625,0.09888441223618309,0.972,6.7074557
+24.0,0.01641095299800649,0.995875,0.09965806453354788,0.972,6.6145583
+25.0,0.01586228150445892,0.996,0.10052734547893757,0.972,6.6785008
+26.0,0.015242585156170526,0.996125,0.09972586259946029,0.973,6.6458647
+27.0,0.014541873346726793,0.99625,0.09589592826226206,0.975,6.6931299
+28.0,0.014111385430471367,0.9965,0.09333730044410025,0.975,6.6936154
+29.0,0.01355843865332935,0.996625,0.0923201483486971,0.975,6.7194869
+30.0,0.013044136979958827,0.99675,0.09205831919061061,0.975,6.6706737
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_mnist.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_mnist.csv.mtd
new file mode 100644
index 00000000000..18dec607648
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_diagonal_mnist.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 30,
+    "cols": 6,
+    "nnz": 180,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 08:23:46 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_mnist.csv b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_mnist.csv
new file mode 100644
index 00000000000..edee4ec1979
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_mnist.csv
@@ -0,0 +1,30 @@
+1.0,0.6224640948243657,0.804875,0.32950747493499266,0.906,7.8584854
+2.0,0.19464308336653371,0.941,0.19091637765995637,0.937,6.7715694
+3.0,0.1324258190876514,0.959625,0.15967103515599967,0.951,7.0617942
+4.0,0.09979385554203214,0.97025,0.17423058644033812,0.953,6.9296477
+5.0,0.08238696438368712,0.97475,0.17192332629750903,0.953,7.1026953
+6.0,0.06880401176919847,0.97925,0.14573834155133827,0.961,7.1400194
+7.0,0.05797657751243725,0.98175,0.13770676958035194,0.963,7.2705643
+8.0,0.05063433391067297,0.984,0.1263040802874613,0.965,7.3092983
+9.0,0.04424816208799803,0.987375,0.11456810146699636,0.967,7.4507
+10.0,0.038605833210502746,0.989625,0.10643915111975934,0.965,7.613126
+11.0,0.03366075451209213,0.990625,0.10277666118108401,0.966,7.5308594
+12.0,0.029675215071195263,0.992,0.09730944153423055,0.97,7.6363994
+13.0,0.02646271101556241,0.992875,0.09277150674195356,0.972,7.657226
+14.0,0.023675962513854298,0.99375,0.08788504898580567,0.972,7.6837161
+15.0,0.020987538211958978,0.994625,0.08382649417261773,0.974,7.6730989
+16.0,0.01888307181626461,0.995,0.08221422248895804,0.973,7.7181718
+17.0,0.01703607613220249,0.9955,0.08075960651113932,0.974,7.7815203
+18.0,0.015506364081234679,0.995875,0.08045199745858346,0.977,7.7753385
+19.0,0.014289467459344538,0.99625,0.07958424629306447,0.978,7.7582245
+20.0,0.013182272624173395,0.996875,0.07962837080289704,0.978,7.7726161
+21.0,0.011994690871356678,0.997125,0.07930149422003162,0.978,7.8080378
+22.0,0.011139828376244448,0.997125,0.07942869291400452,0.979,7.7090791
+23.0,0.010239096134087742,0.99775,0.07910192088241703,0.979,7.7464873
+24.0,0.009466167053824031,0.998375,0.07806174166067677,0.979,7.8539785
+25.0,0.008831964314231097,0.998625,0.0771226548909102,0.98,7.8088004
+26.0,0.008245407919059039,0.998625,0.076289475479688,0.979,7.805053
+27.0,0.007788109532100104,0.999,0.0749194212032097,0.979,7.7841762
+28.0,0.007199930555454531,0.999125,0.07414262643969086,0.979,7.7958939
+29.0,0.006797875712135046,0.99925,0.07308549584235557,0.981,7.7634307
+30.0,0.006295809051245656,0.99925,0.0723885182610686,0.982,7.7103899
diff --git a/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_mnist.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_mnist.csv.mtd
new file mode 100644
index 00000000000..615fd926292
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/metrics_shampoo_momentum_mnist.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 30,
+    "cols": 6,
+    "nnz": 180,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 08:20:28 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/metrics/update_step_times.csv b/scripts/staging/shampoo_optimizer/metrics/update_step_times.csv
new file mode 100644
index 00000000000..d6ac958abd8
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/update_step_times.csv
@@ -0,0 +1,18 @@
+1.0,1.0,1.0,2.742716E-4
+1.0,1000.0,0,1.102185E-4
+2.0,1.0,1.0,4.170569E-4
+2.0,1000.0,0,0.0041237014
+3.0,1.0,1.0,2.424262E-4
+3.0,1000.0,0,0.0040937931
+4.0,1.0,1.0,3.2715470000000004E-4
+4.0,1000.0,0,0.0041171109
+5.0,1.0,1.0,2.865899E-4
+5.0,1000.0,0,0.0041658312
+6.0,1.0,1.0,4.196396E-4
+6.0,1000.0,0,8.759079E-4
+7.0,1.0,1.0,2.838581E-4
+7.0,1000.0,0,8.068506E-4
+8.0,1.0,1.0,2.062514E-4
+8.0,1000.0,0,2.0907039999999998E-4
+9.0,1.0,1.0,3.96182E-5
+9.0,1000.0,0,3.98469E-5
diff --git a/scripts/staging/shampoo_optimizer/metrics/update_step_times.csv.mtd b/scripts/staging/shampoo_optimizer/metrics/update_step_times.csv.mtd
new file mode 100644
index 00000000000..15856b10f5a
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/metrics/update_step_times.csv.mtd
@@ -0,0 +1,12 @@
+{
+    "data_type": "matrix",
+    "value_type": "double",
+    "rows": 18,
+    "cols": 4,
+    "nnz": 63,
+    "format": "csv",
+    "author": "nicol",
+    "header": false,
+    "sep": ",",
+    "created": "2026-02-16 11:28:15 MEZ"
+}
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/readme.md b/scripts/staging/shampoo_optimizer/readme.md
new file mode 100644
index 00000000000..358e06bc533
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/readme.md
@@ -0,0 +1,69 @@
+# Shampoo Experiments
+
+These experiments evaluate an implementation of the Shampoo optimizer, as described in: Gupta et al., “Shampoo: Preconditioned Stochastic Tensor Optimization” (<https://arxiv.org/abs/1802.09568>).
+Shampoo is a second-order optimizer that preconditions gradients using estimates of the row- and column-wise gradient covariance. Compared to first-order optimizers such as SGD and Adam, Shampoo can converge faster, but it is typically more memory- and compute-intensive.
+
+Experimental Setup:
+    - Model: A simple two-layer CNN.
+    - Datasets: MNIST and CIFAR-10.
+    - CIFAR-10 regularization:
+    To reduce overfitting during the 200 training epochs:
+        - the CIFAR-10 training set is augmented (original + augmented copy),
+        - a dropout layer is used.
+
+Implemented Shampoo Variants_
+    - Following Gupta et al., three Shampoo variants were implemented:
+        - Classic Shampoo (baseline)
+        - Shampoo + Momentum
+        - Heuristic Shampoo: momentum + computing the expensive matrix-root steps only every n updates (to reduce compute cost)
+
+    Additionally, the diagonal approximation (avoiding full eigendecomposition) is considered where applicable.
+
+Baselines and Hyperparameter Tuning_
+    - The Shampoo variants are compared against three common optimizers:
+        - SGD
+        - Adam
+        - Adagrad
+    - For every optimizer, hyperparameter tuning was performed. Importantly, no optimizer was tuned more extensively than the others. This means the results may not represent the absolute best achievable performance for each method, but the comparison better reflects:
+        - how sensitive each optimizer is to tuning, and
+        - how easy it is to obtain strong results in practice.
+
+Results Overview
+
+    A full overview of results (plots) is provided in: experiment_results.ipynb
+
+    - Summary
+        - MNIST
+            - The Shampoo variants perform very well and typically converge faster.
+            - A single update step is slightly slower, but fewer epochs may be required.
+        - CIFAR-10
+            - Shampoo variants perform worse than SGD and Adam in this setup.
+            - A possible reason is that Shampoo benefits less in regimes where the model is underfitting or the setting strongly favors first-order methods.
+        - Diagonal Shampoo
+            - Slightly worse final performance than full Shampoo,
+            - Reduces compute cost and improves time-to-convergence.
+        - Heuristic Shampoo
+            - Saves compute time, but performs worse in these experiments.
+            - The diagonal variant often provides better trade-offs (faster and better-performing than the heuristic here).
+            - Note: The original paper reports strong heuristic performance. The weaker results here may be due to the simplicity of the CNN or the specific dataset/training setup.
+
+How to Run
+
+    1. Create the CIFAR-10 CSV dataset (needed for CIFAR experiments):
+        - Run: cifar_creation.py
+    2. Single-step timing benchmark (optimizer update time):
+        - Run: shampoo_experiment_time.dml
+    3. Full training experiments (main benchmark):
+        - Run: shamoo_optimizer_experiments.dml
+        - At the end of the file, you can select:
+            - standard experiments, or
+            - hyperparameter fine-tuning runs (with relevant parameters)
+        - For standard experiments, you can also adjust parameters in:
+            - definingTrainingParameters
+            - definingModelParameters
+            - definingData
+        - Adjust the values in the function "getOptimizer" to change the optimizers that are supposed to be used
+        - Note: Default values are already tuned, changing them is not recommended unless you intentionally want a different experimental setup.
+    4. (Optional) ResNet experiments
+        - If you have enough compute, you can use: shampoo_optimizer_experiments_resnet.dml
+        - Be aware: this pipeline is not optimized. It may be necessary to modify "definingData" to use more data and adjust dataset handling.
diff --git a/scripts/staging/shampoo_optimizer/shampoo_experiment_time.dml b/scripts/staging/shampoo_optimizer/shampoo_experiment_time.dml
new file mode 100644
index 00000000000..c4749395422
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/shampoo_experiment_time.dml
@@ -0,0 +1,174 @@
+#-------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+#-------------------------------------------------------------
+
+source("scripts/nn/optim/shampoo.dml") as shampoo
+source("scripts/nn/optim/adagrad.dml") as adagrad
+source("scripts/nn/optim/adam.dml") as adam
+source("scripts/nn/optim/sgd.dml") as sgd
+
+
+getOptimizer = function(int optimizerIndex)
+    return(string optimizer){
+    /*
+    * Maps an integer index to an optimizer name string used throughout the
+    * experiment pipeline.
+    *
+    * Inputs:
+    *  - optimizerIndex: Integer identifier of the optimizer (1..9)
+    *
+    * Outputs:
+    *  - optimizer: Optimizer name corresponding to the index.
+    */
+        if (optimizerIndex==1)
+        {
+            optimizer = "adam"
+        }
+        if (optimizerIndex==2)
+        {
+            optimizer = "shampoo"
+        }
+        if (optimizerIndex==3)
+        {
+            optimizer = "shampoo_momentum"
+        }
+        if (optimizerIndex==4)
+        {
+            optimizer = "shampoo_heuristic"
+        }
+        if (optimizerIndex==5)
+        {
+            optimizer = "adagrad"
+        }
+        if (optimizerIndex==6)
+        {
+            optimizer = "sgd"
+        }
+}
+
+optimizersToExperiment = list("shampoo", "shampoo_momentum", "shampoo_heuristic","adam",
+            "adagrad", "sgd")
+
+epsilon = 1e-4
+lr = 0.005
+rootEvery=10
+preconEvery=10
+
+X0  = rand(rows=100, cols=100, min=-1, max=1, pdf="uniform", sparsity=1.0, seed=7)
+dX0 = rand(rows=100, cols=100, min=-1, max=1, pdf="uniform", sparsity=1.0, seed=8)
+
+nSteps = 5000
+
+results = matrix(0, rows=length(optimizersToExperiment) * 2, cols=4)
+row = 0
+
+for (optimizerIndex in 1:length(optimizersToExperiment)) {
+
+  optimizer = getOptimizer(optimizerIndex)
+
+  # two modes: diagonal vs non-diagonal
+  for (diagThreshold in seq(1, 1000, 999)) {
+
+    X  = X0
+    dX = dX0
+
+    timestep = 0
+
+    # init state
+    if ((optimizer == "shampoo") | (optimizer == "shampoo_diagonal")) {
+      [preconL, preconR, useDiag] = shampoo::init(X, epsilon, diagThreshold)
+    } else if ((optimizer == "shampoo_momentum") | (optimizer == "shampoo_momentum_diagonal")) {
+      [preconL, preconR, momentum, useDiag] = shampoo::init_momentum(X, epsilon, diagThreshold)
+    } else if ((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")) {
+      [preconL, preconR, stepCounter, bufferL, bufferR, momentum, preconLInvPowerRoot, preconRInvPowerRoot, useDiag] = shampoo::init_heuristic(X, epsilon, diagThreshold)
+    } else if (optimizer == "adam") {
+      [m, v] = adam::init(X)
+    } else if (optimizer == "adagrad") {
+      cache = adagrad::init(X)
+    }
+
+    # warmup
+    if (optimizer == "sgd") {
+      X = sgd::update(X, dX, lr)
+    } else if (optimizer == "adagrad") {
+      [X, cache] = adagrad::update(X, dX, lr, epsilon, cache)
+    } else if (optimizer == "adam") {
+      [X, m, v] = adam::update(X, dX, lr, 0.9, 0.999, epsilon, timestep, m, v)
+      timestep = timestep + 1
+    } else if ((optimizer == "shampoo") | (optimizer == "shampoo_diagonal")) {
+      [X, preconL, preconR] = shampoo::update(X, dX, lr, preconL, preconR, useDiag)
+    } else if ((optimizer == "shampoo_momentum") | (optimizer == "shampoo_momentum_diagonal")) {
+      [X, preconL, preconR, momentum] = shampoo::update_momentum(X, dX, lr, preconL, preconR, momentum, useDiag)
+    } else if ((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")) {
+      [X, preconL, preconR, momentum, stepCounter, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot] = shampoo::update_heuristic(X, dX, lr, preconL, preconR, momentum, stepCounter, rootEvery, preconEvery, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot, useDiag)
+    }
+
+    # timed loop
+    t0 = time()
+    
+    if (optimizer == "sgd") {
+      for (step in 1:nSteps) {
+        X = sgd::update(X, dX, lr)
+      }
+    } else if (optimizer == "adagrad") {
+      for (step in 1:nSteps) {
+        [X, cache] = adagrad::update(X, dX, lr, epsilon, cache)
+      }
+    } else if (optimizer == "adam") {
+      for (step in 1:nSteps) {
+        [X, m, v] = adam::update(X, dX, lr, 0.9, 0.999, epsilon, timestep, m, v)
+        timestep = timestep + 1
+      }
+    } else if ((optimizer == "shampoo") | (optimizer == "shampoo_diagonal")) {
+      for (step in 1:nSteps) {
+        [X, preconL, preconR] = shampoo::update(X, dX, lr, preconL, preconR, useDiag)
+      }
+    } else if ((optimizer == "shampoo_momentum") | (optimizer == "shampoo_momentum_diagonal")) {
+      for (step in 1:nSteps) {
+        [X, preconL, preconR, momentum] = shampoo::update_momentum(X, dX, lr, preconL, preconR, momentum, useDiag)
+      }
+    } else if ((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")) {
+      for (step in 1:nSteps) {
+        [X, preconL, preconR, momentum, stepCounter, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot] = shampoo::update_heuristic(X, dX, lr, preconL, preconR, momentum, stepCounter, rootEvery, preconEvery, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot, useDiag)
+      }
+    }
+    
+    t1 = time()
+
+    diagonal = 0 
+    if (diagThreshold == 1){ 
+      diagonal = 1 
+    } else { 
+      diagonal = 0
+    }
+ 
+    timeSec = (t1 - t0) / 1000000000 / nSteps
+
+    row = row + 1
+    results[row,1] = optimizerIndex
+    results[row,2] = diagThreshold
+    results[row,3] = diagonal
+    results[row,4] = timeSec
+
+    print("Time per update (" + optimizer + ", " + diagonal + ") = " + timeSec + " sec")
+  }
+}
+outDir = "scripts/staging/shampoo_optimizer/metrics"
+write(results, outDir + "/update_step_times.csv", format="csv")
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/shampoo_optimizer_experiments.dml b/scripts/staging/shampoo_optimizer/shampoo_optimizer_experiments.dml
new file mode 100644
index 00000000000..b1116188182
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/shampoo_optimizer_experiments.dml
@@ -0,0 +1,997 @@
+#-------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+#-------------------------------------------------------------
+
+source("scripts/nn/optim/shampoo.dml") as shampoo
+source("scripts/nn/optim/adagrad.dml") as adagrad
+source("scripts/nn/optim/adam.dml") as adam
+source("scripts/nn/optim/sgd.dml") as sgd
+
+source("scripts/nn/layers/conv2d_builtin.dml") as conv2d
+source("scripts/nn/layers/avg_pool2d_builtin.dml") as avg_pool2d
+source("scripts/nn/layers/relu.dml") as relu
+source("scripts/nn/layers/cross_entropy_loss.dml") as cross_entropy_loss
+source("scripts/nn/layers/softmax.dml") as softmax
+source("scripts/nn/layers/dropout.dml") as dropout
+
+source("src/test/scripts/applications/nn/util.dml") as test_util
+
+
+# defining forward pass
+modelPredict = function(matrix[double] X, matrix[double] W1, matrix[double] b1, matrix[double] W2, matrix[double] b2, matrix[double] wFC, matrix[double] bFC, list[unknown] hIns, list[unknown] wIns, list[unknown] cIns, boolean isTraining, string datasetName)
+    return(matrix[double] softMaxOut, matrix[double] X, matrix[double] convOut1, matrix[double] poolOut1, matrix[double] reluOut1, matrix[double] convOut2, matrix[double] poolOut2, matrix[double] reluOut2, matrix[double] pred, matrix[double] mask2){ 
+    /*
+    * Forward pass for the 2-layer CNN image classifier.
+    *
+    * Computes:
+    *  - Conv2D -> AvgPool2D -> ReLU  (block 1)
+    *  - Conv2D -> AvgPool2D -> ReLU  (block 2)
+    *  - (optional) Dropout on CIFAR during training
+    *  - Linear layer (fully-connected) and Softmax
+    *
+    * Inputs:
+    *  - X: Input batch matrix (flattened images).
+    *  - W1, b1: Weights and bias for the first convolution layer.
+    *  - W2, b2: Weights and bias for the second convolution layer.
+    *  - wFC, bFC: Weights and bias for the fully-connected layer.
+    *  - hIns, wIns, cIns: Lists containing input/intermediate heights, widths, and channels
+    *                      required by the conv/pool operators.
+    *  - isTraining: If TRUE, enables training-only behavior (dropout).
+    *  - datasetName: Dataset identifier (e.g., "mnist", "cifar") to trigger dataset-specific logic.
+    *
+    * Outputs:
+    *  - softMaxOut: Softmax probabilities for each class.
+    *  - X: The input X (returned for convenience/caching).
+    *  - convOut1, poolOut1, reluOut1: Cached activations after block 1.
+    *  - convOut2, poolOut2, reluOut2: Cached activations after block 2.
+    *  - pred: Pre-softmax logits (linear layer output).
+    *  - mask2: Dropout mask (1x1 dummy matrix if dropout is not applied).
+    */
+        filters = 64
+        convKernel = 5
+        poolKernel = 4
+        convPadding = 2
+        poolPadding = 1
+
+        hIn = as.integer(as.scalar(hIns[1]))
+        hIn1 = as.integer(as.scalar(hIns[2]))
+        hIn2 = as.integer(as.scalar(hIns[3]))
+        hIn3 = as.integer(as.scalar(hIns[4]))
+        hIn4 = as.integer(as.scalar(hIns[5]))
+
+        wIn = as.integer(as.scalar(wIns[1]))
+        wIn1 = as.integer(as.scalar(wIns[2]))
+        wIn2 = as.integer(as.scalar(wIns[3]))
+        wIn3 = as.integer(as.scalar(wIns[4]))
+        wIn4 = as.integer(as.scalar(wIns[5]))
+
+        cIn = as.integer(as.scalar(cIns[1]))
+        cIn1 = as.integer(as.scalar(cIns[2]))
+
+        # first block
+        [convOut1, Hout, Wout] = conv2d::forward(X, W1, b1, cIn, hIn, wIn, convKernel, convKernel, 1, 1, convPadding, convPadding)
+
+        [poolOut1, Hout, Wout] = avg_pool2d::forward(convOut1, cIn1, hIn1, wIn1, poolKernel, poolKernel, 2, 2, poolPadding, poolPadding)
+
+        reluOut1 = relu::forward(poolOut1)
+
+        # second block
+        [convOut2, Hout, Wout] = conv2d::forward(reluOut1, W2, b2, cIn1, hIn2, wIn2, convKernel, convKernel, 1, 1, convPadding, convPadding)
+
+        [poolOut2, Hout, Wout] = avg_pool2d::forward(convOut2, cIn1, hIn3, wIn3, poolKernel, poolKernel, 2, 2, poolPadding, poolPadding)
+
+        reluOut2 = relu::forward(poolOut2)
+
+        mask2 = matrix(1, rows=1, cols=1)
+        if (datasetName == "cifar" & isTraining){
+            pDropout = 0.3 
+            [dropOut2, mask2] = dropout::forward(reluOut2, pDropout, -1)
+            pred = dropOut2 %*% t(wFC) + t(bFC)
+        }else{
+            pred = reluOut2 %*% t(wFC) + t(bFC)
+        }
+
+        softMaxOut = softmax::forward(pred)
+
+        #Xs = list(X, convOut1, poolOut1, reluOut1, convOut2, poolOut2, reluOut2, pred, softMaxOut)
+
+    }
+
+#defining backward pass
+modelBackward = function(matrix[double] target, matrix[double] W1, matrix[double] b1, matrix[double] W2, matrix[double] b2, matrix[double] wFC, matrix[double] bFC, list[unknown] hIns, list[unknown] wIns, list[unknown] cIns, matrix[double] X, matrix[double] convOut1, matrix[double] poolOut1, matrix[double] reluOut1, matrix[double] convOut2, matrix[double] poolOut2, matrix[double] reluOut2, matrix[double] pred, matrix[double] softMaxOut, matrix[double] mask2, string datasetName)
+    return (matrix[double] gradientLinLayerW, matrix[double] gradientLinLayerb, matrix[double] gradientW2, matrix[double] gradientB2, matrix[double] gradientW1, matrix[double] gradientB1){
+    /*
+    * Backward pass for the 2-layer CNN image classifier.
+    *
+    * Computes gradients for:
+    *  - Softmax + Cross-Entropy loss
+    *  - Fully-connected (linear) layer
+    *  - (optional) Dropout on CIFAR
+    *  - ReLU / AvgPool2D / Conv2D blocks (block 2 then block 1)
+    *
+    * The function expects cached forward-pass activations (conv/pool/relu outputs)
+    * to correctly propagate gradients through the network.
+    *
+    * Inputs:
+    *  - target: One-hot encoded labels for the current batch.
+    *  - W1, b1: Weights and bias for the first convolution layer.
+    *  - W2, b2: Weights and bias for the second convolution layer.
+    *  - wFC, bFC: Weights and bias for the fully-connected layer.
+    *  - hIns, wIns, cIns: Lists containing input/intermediate heights, widths, and channels
+    *                      required by the conv/pool backward operators.
+    *  - X: Original input batch (flattened images), as used in the forward pass.
+    *  - convOut1, poolOut1, reluOut1: Cached activations after block 1.
+    *  - convOut2, poolOut2, reluOut2: Cached activations after block 2.
+    *  - pred: Pre-softmax logits from the forward pass.
+    *  - softMaxOut: Softmax probabilities from the forward pass.
+    *  - mask2: Dropout mask from the forward pass (used only for CIFAR training).
+    *  - datasetName: Dataset identifier ("mnist" or "cifar") to trigger dataset-specific logic.
+    *
+    * Outputs:
+    *  - gradientLinLayerW: Gradient of the linear-layer weights (wFC).
+    *  - gradientLinLayerb: Gradient of the linear-layer bias (bFC).
+    *  - gradientW2, gradientB2: Gradients for the second conv layer (W2, b2).
+    *  - gradientW1, gradientB1: Gradients for the first conv layer (W1, b1).
+    */        
+        filters = 64
+        convKernel = 5
+        poolKernel = 4
+        convPadding = 2
+        poolPadding = 1
+
+        hIn = as.integer(as.scalar(hIns[1]))
+        hIn1 = as.integer(as.scalar(hIns[2]))
+        hIn2 = as.integer(as.scalar(hIns[3]))
+        hIn3 = as.integer(as.scalar(hIns[4]))
+        hIn4 = as.integer(as.scalar(hIns[5]))
+
+        wIn = as.integer(as.scalar(wIns[1]))
+        wIn1 = as.integer(as.scalar(wIns[2]))
+        wIn2 = as.integer(as.scalar(wIns[3]))
+        wIn3 = as.integer(as.scalar(wIns[4]))
+        wIn4 = as.integer(as.scalar(wIns[5]))
+
+        cIn = as.integer(as.scalar(cIns[1]))
+        cIn1 = as.integer(as.scalar(cIns[2]))
+
+        # gradient of loss function
+        gradientLossfn = cross_entropy_loss::backward(softMaxOut, target)
+
+        # gradient Softmax
+        gradientSoftmax = softmax::backward(gradientLossfn, pred)
+
+        # gradients Linear layer
+        gradientLinLayerW = t(gradientSoftmax) %*% reluOut2
+        gradientLinLayerb = t(colSums(gradientSoftmax))
+        gradientLinLayerX = gradientSoftmax %*% wFC
+
+        if (datasetName == "cifar"){
+            # Dropout
+            pDropout = 0.3
+            gradientDropout = dropout::backward(gradientLinLayerX, reluOut2, pDropout, mask2)
+            gradientRelu = relu::backward(gradientDropout, poolOut2)
+        }else{
+            # gradient second Relu
+            gradientRelu = relu::backward(gradientLinLayerX, poolOut2)
+        }
+
+        # gradient second pooling layer
+        gradientSecondPooling = avg_pool2d::backward(gradientRelu, hIn4, wIn4, convOut2, cIn1, hIn3, wIn3, poolKernel, poolKernel, 2, 2, poolPadding, poolPadding)
+
+        # gradient second conv layer
+        [gradientSecondConvX, gradientW2, gradientB2] = conv2d::backward(gradientSecondPooling, hIn3, wIn3, reluOut1, W2, b2, cIn1, hIn2, wIn2, convKernel, convKernel, 1, 1, convPadding, convPadding)
+
+        # gradient of the first Relu
+        gradientRelu = relu::backward(gradientSecondConvX, poolOut1)
+
+        # gradient first pooling layer
+        gradientFirstPooling = avg_pool2d::backward(gradientRelu, hIn2, wIn2, convOut1, cIn1, hIn1, wIn1, poolKernel, poolKernel, 2, 2, poolPadding, poolPadding)
+
+        # gradient first conv layer
+        [gradientFirstConvX, gradientW1, gradientB1] = conv2d::backward(gradientFirstPooling, hIn1, wIn1, X, W1, b1, cIn, hIn, wIn, convKernel, convKernel, 1, 1, convPadding, convPadding)
+
+    }
+
+
+definingData = function(string datasetName)
+    return(matrix[double] XTrain, matrix[double] YTrain, matrix[double] XVal, matrix[double] YVal, matrix[double] XTest, matrix[double] YTest){
+    /*
+    * Loads and prepares the dataset split (train/validation/test) for MNIST or CIFAR.
+    *
+    * For MNIST:
+    *  - Reads the CSV from the SystemDS test resources.
+    *  - Normalizes pixel intensities to [0, 1] by dividing by 255.
+    *
+    * For CIFAR:
+    *  - Reads a pre-generated CSV (created by the CIFAR conversion script).
+    *  - Note: No additional normalization is applied here (assumes preprocessing
+    *          was already handled in the CSV generation step).
+    *
+    * Inputs:
+    *  - datasetName: Dataset identifier ("mnist" or "cifar").
+    *
+    * Outputs:
+    *  - XTrain: Training feature matrix (images).
+    *  - YTrain: One-hot encoded training label matrix.
+    *  - XVal: Validation feature matrix.
+    *  - YVal: One-hot encoded validation label matrix.
+    *  - XTest: Test feature matrix.
+    *  - YTest: One-hot encoded test label matrix.
+    */
+    if (datasetName=="mnist"){
+        data = read("src/test/resources/datasets/MNIST/mnist_test.csv", format="csv") 
+        train = data[1:8999,]
+        test = data[9000:nrow(data),] 
+
+        images = train[,2:ncol(train)]
+        images = images / 255.0
+        labels = train[,1]
+        imagesTest = test[,2:ncol(test)]
+        imagesTest = imagesTest / 255.0
+        labelsTest = test[,1]
+
+        N = nrow(images)
+        NTest = nrow(imagesTest)     
+
+        XTrain = images[1001:nrow(images),]
+        labelsTrain = labels[1001:nrow(images),]
+        YTrain = table(seq(1, nrow(XTrain)), labelsTrain+1, nrow(XTrain), 10)      
+
+        XVal = images[1:1000,]
+        labelsVal = labels[1:1000,]
+        YVal = table(seq(1, nrow(XVal)), labelsVal+1, nrow(XVal), 10)
+
+        XTest = imagesTest
+        YTest = table(seq(1, NTest), labelsTest+1, NTest, 10)
+    }
+    if (datasetName=="cifar"){
+        data = read("scripts/staging/shampoo_optimizer/cifar10.csv", format="csv")
+        train = data[1:10000,]   # data[1:40000,]                           
+        test = data[10001:15000,]  # data[40000:nrow(data),]  
+
+        images = train[,2:ncol(train)]
+        labels = train[,1]
+        imagesTest = test[,2:ncol(test)]
+        labelsTest = test[,1]
+
+        N = nrow(images)
+        NTest = nrow(imagesTest)
+
+        XTrain = images[2001:nrow(images),]                  
+        labelsTrain = labels[2001:nrow(images),] 
+        YTrain = table(seq(1, nrow(XTrain)), labelsTrain+1, nrow(XTrain), 10)
+
+        XVal = images[1:2000,]          
+        labelsVal = labels[1:2000,] 
+        YVal = table(seq(1, nrow(XVal)), labelsVal+1, nrow(XVal), 10)
+
+        XTest = imagesTest
+        YTest = table(seq(1, NTest), labelsTest+1, NTest, 10)
+    }
+}
+
+
+definingImageProperties = function(string datasetName)
+    /*
+    * Returns basic image shape metadata for the selected dataset.
+    *
+    * Provides the input height/width, number of channels, and number of classes
+    * for the supported datasets.
+    *
+    * Inputs:
+    *  - datasetName: Dataset identifier ("mnist" or "cifar").
+    *
+    * Outputs:
+    *  - hIn: Input image height.
+    *  - wIn: Input image width.
+    *  - cIn: Number of input channels.
+    *  - classes: Number of classes.
+    */
+    return(int hIn, int wIn, int cIn, int classes){
+    if(datasetName=="mnist"){
+        hIn = 28       
+        wIn = 28       
+        cIn = 1        
+        classes = 10
+    } 
+    if(datasetName=="cifar"){
+        hIn = 32       
+        wIn = 32      
+        cIn = 3        
+        classes = 10
+    }
+}
+
+# Define training parameters
+definingTrainingParameters = function(string optimizer, string datasetName)
+    return(int epochs, int batchSize, double epsilon, double lr, int diagThreshold, int rootEvery, int preconEvery){
+    /*
+    * Returns training hyperparameters (epochs, batch size, and optimizer-specific settings)
+    * for a given optimizer and dataset.
+    *
+    * This function provides preset hyperparameters per optimizer (Adam, Adagrad, SGD,
+    * and three Shampoo variants) and per dataset ("mnist" vs "cifar").
+    *
+    * Inputs:
+    *  - optimizer: Optimizer name.
+    *  - datasetName: Dataset identifier ("mnist" or "cifar").
+    *
+    * Outputs:
+    *  - epochs: Number of training epochs.
+    *  - batchSize: Mini-batch size.
+    *  - epsilon: Numerical stability constant for the selected optimizer/dataset.
+    *  - lr: Learning rate for the selected optimizer/dataset.
+    *  - diagThreshold: Shampoo diagonalization threshold
+    *  - rootEvery: Frequency for computing matrix roots in Shampoo heuristic.
+    *  - preconEvery: Frequency for updating preconditioners in heuristic Shampoo.
+    */
+    lr = 0.001
+    if(optimizer=="adam"){
+        if(datasetName=="cifar"){
+            epsilon = 1e-7
+            lr = 5.0e-4 
+        }else{
+            epsilon = 1e-4
+            lr = 0.0015  
+        } 
+    } 
+    else if(optimizer=="adagrad"){
+        if(datasetName=="cifar"){
+            epsilon = 1.0e-5
+            lr = 0.007           
+        }else{
+            epsilon = 1e-5
+            lr = 0.002
+        }
+    } 
+    else if(optimizer=="sgd"){
+        if(datasetName=="cifar"){
+            epsilon = 1.0e-8
+            lr = 0.1    
+        }else{
+            epsilon = 1e-6
+            lr = 0.03              
+        }
+    } 
+    else if((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")){
+        if(datasetName=="cifar"){
+            epsilon = 0.09
+            lr = 0.2    
+        } else{
+            epsilon = 0.001
+            lr = 0.1   
+        }
+    } 
+    else if((optimizer == "shampoo_momentum") | (optimizer == "shampoo_momentum_diagonal")){
+        if(datasetName=="cifar"){
+            epsilon = 1.0e-7
+            lr = 0.3    
+        } else{
+            epsilon = 1e-4 
+            lr = 0.55    
+        }
+    } 
+    else if((optimizer == "shampoo") | (optimizer == "shampoo_diagonal")){
+        if(datasetName=="cifar"){
+            epsilon = 0.09
+            lr = 0.2    
+        } else{
+            epsilon = 0.2 
+            lr = 0.6    
+        }
+    } 
+
+    if(datasetName=="cifar"){
+        epochs = 200     
+    } else{
+        epochs = 30    
+    }
+    batchSize = 64
+    rootEvery = 8  
+    preconEvery = 2
+    if ((optimizer == "shampoo_diagonal") | (optimizer == "shampoo_momentum_diagonal") | (optimizer == "shampoo_heuristic_diagonal")){
+        diagThreshold = 1
+    } else{
+        diagThreshold = 1200
+    }
+}
+
+definingModelParameters = function()
+    /*
+    * Defines and returns fixed model hyperparameters for the CNN architecture.
+    *
+    * This function centralizes the configuration of convolution/pooling settings
+    * and the random seed used for weight initialization.
+    *
+    * Outputs:
+    *  - filters: Number of convolution filters per conv layer.
+    *  - convKernel: Convolution kernel size.
+    *  - poolKernel: Pooling kernel size.
+    *  - convPadding: Padding applied in convolution layers.
+    *  - poolPadding: Padding applied in pooling layers.
+    *  - seed: Random seed for reproducible initialization.
+    */
+    return(int filters, int convKernel, int poolKernel, int convPadding, int poolPadding, int seed){
+    
+    filters = 64
+    convKernel = 5
+    poolKernel = 4
+    convPadding = 2
+    poolPadding = 1
+    seed = 42    
+}
+
+
+definingNNImageClassification = function(int hIn, int wIn, int cIn, int classes, int filters, int convKernel, int poolKernel, int convPadding, int poolPadding, int seed)
+    return(list[unknown] hIns, list[unknown] wIns, list[unknown] cIns, matrix[double] W1, matrix[double] b1, matrix[double] W2, matrix[double] b2, matrix[double] wFC, matrix[double] bFC){
+    /*
+    * Initializes a simple 2-layer CNN for image classification and returns
+    * all learnable parameters plus cached shape metadata for forward/backward passes.
+    *
+    * Architecture:
+    *  - Conv2D (filters, convKernel, padding=convPadding) + bias
+    *  - AvgPool2D (poolKernel, stride=2, padding=poolPadding)
+    *  - ReLU
+    *  - Conv2D (filters, convKernel, padding=convPadding) + bias
+    *  - AvgPool2D (poolKernel, stride=2, padding=poolPadding)
+    *  - ReLU
+    *  - Fully-connected layer to `classes`
+    *
+    * Inputs:
+    *  - hIn, wIn, cIn: Input image height/width/channels
+    *  - classes: Number of output classes
+    *  - filters: Number of conv filters per layer
+    *  - convKernel: Convolution kernel size
+    *  - poolKernel: Pooling kernel size
+    *  - convPadding: Padding for convolution layers
+    *  - poolPadding: Padding for pooling layers
+    *  - seed: Random seed for reproducible initialization
+    *
+    * Outputs:
+    *  - hIns: List of intermediate heights (hIn, hIn1, hIn2, hIn3, hIn4)
+    *  - wIns: List of intermediate widths  (wIn, wIn1, wIn2, wIn3, wIn4)
+    *  - cIns: List of channel sizes (cIn, cIn1)
+    *  - W1, b1: Weights/bias of first conv layer
+    *  - W2, b2: Weights/bias of second conv layer
+    *  - wFC, bFC: Weights/bias of final linear layer
+    */
+
+    # convolution layer 1
+    [W1, b1] = conv2d::init(filters, cIn, convKernel, convKernel, seed)
+    hIn1 = hIn + convPadding*2 - (convKernel - 1)
+    wIn1 = wIn + convPadding*2 - (convKernel - 1)
+    cIn1 = filters
+    # pooling
+    hIn2 = floor((hIn1 + poolPadding*2 - poolKernel)/2)+1
+    wIn2 = floor((wIn1 + poolPadding*2 - poolKernel)/2)+1
+    # relu
+
+    # convolution layer 2
+    [W2, b2] = conv2d::init(filters, cIn1, convKernel, convKernel, seed)
+    hIn3 = hIn2 + convPadding*2 - (convKernel - 1)
+    wIn3 = wIn2 + convPadding*2 - (convKernel - 1)
+    cIn1 = filters
+    # pooling
+    hIn4 = floor((hIn3 + poolPadding*2 - poolKernel)/2)+1
+    wIn4 = floor((wIn3 + poolPadding*2 - poolKernel)/2)+1
+    # relu
+
+    # Linear
+    wFC = rand(rows=classes, cols=hIn4*wIn4*cIn1, pdf="uniform", min=-0.1, max=0.1, seed=seed)
+    bFC = matrix(0, rows=classes, cols=1)
+
+    hIns = list(hIn, hIn1, hIn2, hIn3, hIn4)
+    wIns = list(wIn, wIn1, wIn2, wIn3, wIn4)
+    cIns = list(cIn, cIn1)    
+}
+
+getOptimizer = function(int optimizerIndex)
+    return(string optimizer){
+    /*
+    * Maps an integer index to an optimizer name string used throughout the
+    * experiment pipeline.
+    *
+    * Inputs:
+    *  - optimizerIndex: Integer identifier of the optimizer (1..9)
+    *
+    * Outputs:
+    *  - optimizer: Optimizer name corresponding to the index.
+    */
+        if (optimizerIndex==1)
+        {
+            optimizer = "adam"
+        }
+        if (optimizerIndex==2)
+        {
+            optimizer = "shampoo"
+        }
+        if (optimizerIndex==3)
+        {
+            optimizer = "shampoo_diagonal"
+        }
+        if (optimizerIndex==4)
+        {
+            optimizer = "shampoo_momentum"
+        }
+        if (optimizerIndex==5)
+        {
+            optimizer = "shampoo_momentum_diagonal"
+        }
+        if (optimizerIndex==6)
+        {
+            optimizer = "shampoo_heuristic"
+        }
+        if (optimizerIndex==7)
+        {
+            optimizer = "shampoo_heuristic_diagonal"
+        }
+        if (optimizerIndex==8)
+        {
+            optimizer = "adagrad"
+        }
+        if (optimizerIndex==9)
+        {
+            optimizer = "sgd"
+        }
+}
+
+runTraining = function(string type, double epsilon, double lr, int rootEvery, int preconEvery, int epochs, string datasetName, int optimizersToExperiment)
+    return(double loss, double accuracy){
+    /*
+    * Trains the two-layer CNN for one or multiple optimizers and returns the
+    * final test loss/accuracy of the last executed optimizer.
+    *
+    * This function:
+    *  - Loads and splits the requested dataset (MNIST/CIFAR)
+    *  - Initializes model weights and optimizer state
+    *  - Runs minibatch training for the specified number of epochs
+    *  - Tracks train/validation loss and accuracy per epoch
+    *  - Measures wall-clock time per epoch (seconds)
+    *  - Evaluates on the test set and optionally writes metrics to CSV
+    *
+    * Inputs:
+    *  - type: Experiment mode string:
+    *      - "training": use standard tuned params from definingTrainingParameters
+    *      - "finetuning": override rootEvery/preconEvery from caller, keep eps/lr from tuning loop
+    *      - "finetuningShampooHeuristics": tune eps/lr/rootEvery/preconEvery externally, do not override from definingTrainingParameters
+    *  - epsilon: Epsilon value potentially provided by hyperparameter tuning (may be overwritten depending on type)
+    *  - lr: Learning rate potentially provided by hyperparameter tuning (may be overwritten depending on type)
+    *  - rootEvery: Shampoo heuristic parameter (may be overwritten depending on type)
+    *  - preconEvery: Shampoo heuristic parameter (may be overwritten depending on type)
+    *  - epochs: Number of epochs (may be overwritten depending on type/dataset)
+    *  - datasetName: Dataset identifier ("mnist" or "cifar")
+    *  - optimizersToExperiment: Number of optimizers to run (iterates optimizerIndex=1..optimizersToExperiment)
+    *
+    * Outputs:
+    *  - loss: Final test loss of the last optimizer run
+    *  - accuracy: Final test accuracy of the last optimizer run
+    */
+    for (optimizerIndex in 1:optimizersToExperiment){
+        optimizer = getOptimizer(optimizerIndex)
+        print("Starting with " + optimizer)
+
+        # get the data
+        [XTrain, YTrain, XVal, YVal, XTest, YTest] = definingData(datasetName)
+
+        # get image properties
+        [hIn, wIn, cIn, classes] = definingImageProperties(datasetName)
+
+        # get model parameters
+        [filters, convKernel, poolKernel, convPadding, poolPadding, seed] = definingModelParameters()
+
+        #get model weights
+        [hIns, wIns, cIns, W1, b1, W2, b2, wFC, bFC] = definingNNImageClassification(hIn, wIn, cIn, classes, filters, convKernel, poolKernel, convPadding, poolPadding, seed)
+
+        # get training parameters
+        if (type == "finetuningShampooHeuristics"){
+            [tmpEpochs, batchSize, tmpEps, tmpLr, diagThreshold, tmpRoot, tmpPrecon]= definingTrainingParameters(optimizer, datasetName)
+        }else if (type == "finetuning"){
+            [tmpEpochs, batchSize, tmpEps, tmpLr, diagThreshold, rootEvery, preconEvery]= definingTrainingParameters(optimizer, datasetName)
+        } else{
+            [epochs, batchSize, epsilon, lr, diagThreshold, rootEvery, preconEvery]= definingTrainingParameters(optimizer, datasetName)
+        }
+        
+
+
+        if ((optimizer == "shampoo") | (optimizer == "shampoo_diagonal")){
+            [preconLW1, preconRW1, useDiagW1] = shampoo::init(W1, epsilon, diagThreshold)
+            [preconLB1, preconRB1, useDiagB1] = shampoo::init(b1, epsilon, diagThreshold)
+            [preconLW2, preconRW2, useDiagW2] = shampoo::init(W2, epsilon, diagThreshold)
+            [preconLB2, preconRB2, useDiagB2] = shampoo::init(b2, epsilon, diagThreshold)
+            [preconLWFC, preconRWFC, useDiagWFC] = shampoo::init(wFC, epsilon, diagThreshold)
+            [preconLBFC, preconRBFC, useDiagBFC] = shampoo::init(bFC, epsilon, diagThreshold)
+        }
+        if ((optimizer == "shampoo_momentum") | (optimizer == "shampoo_momentum_diagonal")){
+            [preconLW1, preconRW1, momentumW1, useDiagW1] = shampoo::init_momentum(W1, epsilon, diagThreshold)
+            [preconLB1, preconRB1, momentumB1, useDiagB1] = shampoo::init_momentum(b1, epsilon, diagThreshold)
+            [preconLW2, preconRW2, momentumW2, useDiagW2] = shampoo::init_momentum(W2, epsilon, diagThreshold)
+            [preconLB2, preconRB2, momentumB2, useDiagB2] = shampoo::init_momentum(b2, epsilon, diagThreshold)
+            [preconLWFC, preconRWFC, momentumWFC, useDiagWFC] = shampoo::init_momentum(wFC, epsilon, diagThreshold)
+            [preconLBFC, preconRBFC, momentumBFC, useDiagBFC] = shampoo::init_momentum(bFC, epsilon, diagThreshold)
+        }
+        if ((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")){
+            [preconLW1, preconRW1, stepCounterW1, bufferLW1, bufferRW1, momentumW1, preconLInvPowerRootW1, preconRInvPowerRootW1, useDiagW1] = shampoo::init_heuristic(W1, epsilon, diagThreshold)
+            [preconLB1, preconRB1, stepCounterB1, bufferLB1, bufferRB1, momentumB1, preconLInvPowerRootB1, preconRInvPowerRootB1, useDiagB1] = shampoo::init_heuristic(b1, epsilon, diagThreshold)
+            [preconLW2, preconRW2, stepCounterW2, bufferLW2, bufferRW2, momentumW2, preconLInvPowerRootW2, preconRInvPowerRootW2, useDiagW2] = shampoo::init_heuristic(W2, epsilon, diagThreshold)
+            [preconLB2, preconRB2, stepCounterB2, bufferLB2, bufferRB2, momentumB2, preconLInvPowerRootB2, preconRInvPowerRootB2, useDiagB2] = shampoo::init_heuristic(b2, epsilon, diagThreshold)
+            [preconLWFC, preconRWFC, stepCounterWFC, bufferLWFC, bufferRWFC, momentumWFC, preconLInvPowerRootWFC, preconRInvPowerRootWFC, useDiagWFC] = shampoo::init_heuristic(wFC, epsilon, diagThreshold)
+            [preconLBFC, preconRBFC, stepCounterBFC, bufferLBFC, bufferRBFC, momentumBFC, preconLInvPowerRootBFC, preconRInvPowerRootBFC, useDiagBFC] = shampoo::init_heuristic(bFC, epsilon, diagThreshold)
+        }
+        if (optimizer == "adam"){
+            [mW1, vW1] = adam::init(W1)
+            [mB1, vB1] = adam::init(b1)
+            [mW2, vW2] = adam::init(W2)
+            [mB2, vB2] = adam::init(b2)
+            [mWFC, vWFC] = adam::init(wFC)
+            [mBFC, vBFC] = adam::init(bFC)
+        }
+        if (optimizer == "adagrad"){
+            cacheW1 = adagrad::init(W1)
+            cacheB1 = adagrad::init(b1)
+            cacheW2 = adagrad::init(W2)
+            cacheB2 = adagrad::init(b2)
+            cacheWFC = adagrad::init(wFC)
+            cacheBFC = adagrad::init(bFC)
+        }
+
+        dataValX = XVal
+        dataValY = YVal
+
+        # define the training
+
+        trainLosses = matrix(0, rows=epochs, cols=1)
+        trainAccuracies = matrix(0, rows=epochs, cols=1)
+        valAccuracies = matrix(0, rows=epochs, cols=1)
+        valLosses = matrix(0, rows=epochs, cols=1)
+        times = matrix(0, rows=epochs, cols=1)
+        Ntrain = nrow(XTrain)
+
+        timestep = 0
+
+        for(epoch in 1:epochs){
+            t0 = time()
+            if (datasetName == "cifar"){
+                if (epoch > 1 & (epoch-1) %% 20 == 0) {
+                        lr = lr * 0.5
+                        print("Learning rate decayed to: " + lr)
+                    }
+            }
+
+            print("Epoch " + epoch + " of " + epochs + " epochs")
+
+            accuracyValue = 0
+            accuracyCount = 0
+            lossValue = 0
+            lossCount = 0
+            
+
+            for(start_index in seq(1, Ntrain, batchSize)){
+                #start_index = (i - 1) * batchSize + 1
+                end_index = min(start_index + batchSize - 1, Ntrain)
+                data_train_X = XTrain[start_index:end_index,]
+                dataTrainY = YTrain[start_index:end_index,]
+
+                [softMaxOut, X, convOut1, poolOut1, reluOut1, convOut2, poolOut2, reluOut2, pred, mask2] = modelPredict(data_train_X, W1, b1, W2, b2, wFC, bFC, hIns, wIns, cIns, TRUE, datasetName)
+
+                predictedValue = rowIndexMax(softMaxOut) - 1
+                accuracy = sum(predictedValue==rowIndexMax(dataTrainY)-1) / length(predictedValue)
+                accuracyValue = accuracyValue + accuracy
+                accuracyCount = accuracyCount + 1
+
+                loss = cross_entropy_loss::forward(softMaxOut, dataTrainY)
+                lossValue = lossValue + loss
+                lossCount = lossCount + 1
+                
+
+                [gradientLinLayerW, gradientLinLayerb, gradientW2, gradientB2, gradientW1, gradientB1] = modelBackward(dataTrainY, W1, b1, W2, b2, wFC, bFC, hIns, wIns, cIns, X, convOut1, poolOut1, reluOut1, convOut2, poolOut2, reluOut2, pred, softMaxOut, mask2, datasetName)
+
+                if ((optimizer == "shampoo") | (optimizer == "shampoo_diagonal")){
+                    [W1, preconLW1, preconRW1] = shampoo::update(W1, gradientW1, lr, preconLW1, preconRW1, useDiagW1)
+                    [b1, preconLB1, preconRB1] = shampoo::update(b1, gradientB1, lr, preconLB1, preconRB1, useDiagB1)
+                    [W2, preconLW2, preconRW2] = shampoo::update(W2, gradientW2, lr, preconLW2, preconRW2, useDiagW2)
+                    [b2, preconLB2, preconRB2] = shampoo::update(b2, gradientB2, lr, preconLB2, preconRB2, useDiagB2)
+                    [wFC, preconLWFC, preconRWFC] = shampoo::update(wFC, gradientLinLayerW, lr, preconLWFC, preconRWFC, useDiagWFC)
+                    [bFC, preconLBFC, preconRBFC] = shampoo::update(bFC, gradientLinLayerb, lr, preconLBFC, preconRBFC, useDiagBFC)
+                }
+                if ((optimizer == "shampoo_momentum") | (optimizer == "shampoo_momentum_diagonal")){
+                    [W1, preconLW1, preconRW1, momentumW1] = shampoo::update_momentum(W1, gradientW1, lr, preconLW1, preconRW1, momentumW1, useDiagW1)
+                    [b1, preconLB1, preconRB1, momentumB1] = shampoo::update_momentum(b1, gradientB1, lr, preconLB1, preconRB1, momentumB1, useDiagB1)
+                    [W2, preconLW2, preconRW2, momentumW2] = shampoo::update_momentum(W2, gradientW2, lr, preconLW2, preconRW2, momentumW2, useDiagW2)
+                    [b2, preconLB2, preconRB2, momentumB2] = shampoo::update_momentum(b2, gradientB2, lr, preconLB2, preconRB2, momentumB2, useDiagB2)
+                    [wFC, preconLWFC, preconRWFC, momentumWFC] = shampoo::update_momentum(wFC, gradientLinLayerW, lr, preconLWFC, preconRWFC, momentumWFC, useDiagWFC)
+                    [bFC, preconLBFC, preconRBFC, momentumBFC] = shampoo::update_momentum(bFC, gradientLinLayerb, lr, preconLBFC, preconRBFC, momentumBFC, useDiagBFC)
+                }
+                if ((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")){
+                    [W1, preconLW1, preconRW1, momentumW1, stepCounterW1, bufferLW1, bufferRW1, preconLInvPowerRootW1, preconRInvPowerRootW1] = shampoo::update_heuristic(W1, gradientW1, lr, preconLW1, preconRW1, momentumW1, stepCounterW1, rootEvery, preconEvery, bufferLW1, bufferRW1, preconLInvPowerRootW1, preconRInvPowerRootW1, useDiagW1)
+                    [b1, preconLB1, preconRB1, momentumB1, stepCounterB1, bufferLB1, bufferRB1, preconLInvPowerRootB1, preconRInvPowerRootB1] = shampoo::update_heuristic(b1, gradientB1, lr, preconLB1, preconRB1, momentumB1, stepCounterB1, rootEvery, preconEvery, bufferLB1, bufferRB1, preconLInvPowerRootB1, preconRInvPowerRootB1, useDiagB1)
+                    [W2, preconLW2, preconRW2, momentumW2, stepCounterW2, bufferLW2, bufferRW2, preconLInvPowerRootW2, preconRInvPowerRootW2] = shampoo::update_heuristic(W2, gradientW2, lr, preconLW2, preconRW2, momentumW2, stepCounterW2, rootEvery, preconEvery, bufferLW2, bufferRW2, preconLInvPowerRootW2, preconRInvPowerRootW2, useDiagW2)
+                    [b2, preconLB2, preconRB2, momentumB2, stepCounterB2, bufferLB2, bufferRB2, preconLInvPowerRootB2, preconRInvPowerRootB2] = shampoo::update_heuristic(b2, gradientB2, lr, preconLB2, preconRB2, momentumB2, stepCounterB2, rootEvery, preconEvery, bufferLB2, bufferRB2, preconLInvPowerRootB2, preconRInvPowerRootB2, useDiagB2)
+                    [wFC, preconLWFC, preconRWFC, momentumWFC, stepCounterWFC, bufferLWFC, bufferRWFC, preconLInvPowerRootWFC, preconRInvPowerRootWFC] = shampoo::update_heuristic(wFC, gradientLinLayerW, lr, preconLWFC, preconRWFC, momentumWFC, stepCounterWFC, rootEvery, preconEvery, bufferLWFC, bufferRWFC, preconLInvPowerRootWFC, preconRInvPowerRootWFC, useDiagWFC)
+                    [bFC, preconLBFC, preconRBFC, momentumBFC, stepCounterBFC, bufferLBFC, bufferRBFC, preconLInvPowerRootBFC, preconRInvPowerRootBFC] = shampoo::update_heuristic(bFC, gradientLinLayerb, lr, preconLBFC, preconRBFC, momentumBFC, stepCounterBFC, rootEvery, preconEvery, bufferLBFC, bufferRBFC, preconLInvPowerRootBFC, preconRInvPowerRootBFC, useDiagBFC)
+                }
+                if (optimizer == "adam"){
+                    [W1, mW1, vW1] = adam::update(W1, gradientW1, lr, 0.9, 0.999, epsilon, timestep, mW1, vW1)
+                    [b1, mB1, vB1] = adam::update(b1, gradientB1, lr, 0.9, 0.999, epsilon, timestep, mB1, vB1)
+                    [W2, mW2, vW2] = adam::update(W2, gradientW2, lr, 0.9, 0.999, epsilon, timestep, mW2, vW2)
+                    [b2, mB2, vB2] = adam::update(b2, gradientB2, lr, 0.9, 0.999, epsilon, timestep, mB2, vB2)
+                    [wFC, mWFC, vWFC] = adam::update(wFC, gradientLinLayerW, lr, 0.9, 0.999, epsilon, timestep, mWFC, vWFC)
+                    [bFC, mBFC, vBFC] = adam::update(bFC, gradientLinLayerb, lr, 0.9, 0.999, epsilon, timestep, mBFC, vBFC)
+                    timestep = timestep + 1
+                }
+                if (optimizer == "adagrad"){
+                    [W1, cacheW1] = adagrad::update(W1, gradientW1, lr, epsilon, cacheW1)
+                    [b1, cacheB1] = adagrad::update(b1, gradientB1, lr, epsilon, cacheB1)
+                    [W2, cacheW2] = adagrad::update(W2, gradientW2, lr, epsilon, cacheW2)
+                    [b2, cacheB2] = adagrad::update(b2, gradientB2, lr, epsilon, cacheB2)
+                    [wFC, cacheWFC] = adagrad::update(wFC, gradientLinLayerW, lr, epsilon, cacheWFC)
+                    [bFC, cacheBFC] = adagrad::update(bFC, gradientLinLayerb, lr, epsilon, cacheBFC)
+                }
+                if (optimizer == "sgd"){
+                    W1 = sgd::update(W1, gradientW1, lr)
+                    b1 = sgd::update(b1, gradientB1, lr)
+                    W2 = sgd::update(W2, gradientW2, lr)
+                    b2 = sgd::update(b2, gradientB2, lr)
+                    wFC = sgd::update(wFC, gradientLinLayerW, lr)
+                    bFC = sgd::update(bFC, gradientLinLayerb, lr)
+                }
+            }
+            t1= time()
+            times[epoch,1] = (t1 - t0) / 1000000000
+
+
+            trainLosses[epoch,1] = lossValue / lossCount
+            trainAccuracies[epoch,1] = accuracyValue/accuracyCount
+
+            #print("Train Loss of " + optimizer + " = " + (lossValue / lossCount))
+            #print("Train Accuracy of " + optimizer + " = " + (accuracyValue/accuracyCount))
+
+            [softMaxOutVal, XVal, convOut1Val, poolOut1Val, reluOut1Val, convOut2Val, poolOut2Val, reluOut2Val, predVal, mask2Ignore] = modelPredict(XVal, W1, b1, W2, b2, wFC, bFC, hIns, wIns, cIns, FALSE, datasetName)
+
+
+            predictedValueVal = rowIndexMax(softMaxOutVal) - 1
+            accuracyVal = sum(predictedValueVal==rowIndexMax(YVal)-1) / length(predictedValueVal)
+
+            valAccuracies[epoch,1] = accuracyVal
+
+            loss = cross_entropy_loss::forward(softMaxOutVal, YVal)
+            valLosses[epoch,1] = loss
+
+            #print("Val Loss of " + optimizer + " = " + loss)
+            #print("Val Accuracy of " + optimizer + " = " + accuracyVal)
+        }
+
+
+        # define the testing
+
+        [softMaxOutTest, XTest, convOut1Test, poolOut1Test, reluOut1Test, convOut2Test, poolOut2Test, reluOut2Test, predTest, mask2Ignore] = modelPredict(XTest, W1, b1, W2, b2, wFC, bFC, hIns, wIns, cIns, FALSE, datasetName)
+
+        predictedValue = rowIndexMax(softMaxOutTest) - 1
+        accuracy = sum(predictedValue==rowIndexMax(YTest)-1) / length(predictedValue)
+
+        loss = cross_entropy_loss::forward(softMaxOutTest, YTest)
+
+        outDir = "scripts/staging/shampoo_optimizer/metrics"
+        epochs = nrow(trainLosses)
+        epochCol = seq(1, epochs)         
+        M = cbind(epochCol, trainLosses, trainAccuracies, valLosses, valAccuracies, times)
+        if ((type != "finetuning") & (type != "finetuningShampooHeuristics")){
+            write(M, outDir + "/metrics" + "_" + optimizer + "_" + datasetName + ".csv", format="csv")
+        }
+        
+        print("Test Accuracy of " + optimizer + " on " + datasetName + " = " + accuracy)
+        print("Test Loss of " + optimizer + " on " + datasetName + " = " + loss)
+
+    }    
+}
+
+logRow = function(matrix[double] L, int run, int roundID, int paramID,
+                   double candidate, double loss, double epsilon, double lr,
+                   int rootEvery, int preconEvery)
+    return(matrix[double] L) {
+/*
+ * Writes one hyperparameter-evaluation record into the tuning log matrix.
+ *
+ * Inputs:
+ *  - L: Tuning log matrix to update (nEval × 8)
+ *  - run: 1-based row index in L to write to
+ *  - roundID: Current tuning round identifier
+ *  - paramID: Identifier of the tuned parameter:
+ *      - 1: epsilon
+ *      - 2: lr
+ *      - 3: rootEvery
+ *      - 4: preconEvery
+ *  - candidate: Candidate value tested for the parameter indicated by paramID
+ *  - loss: Observed loss for this evaluation (e.g., validation loss)
+ *  - epsilon: Epsilon used in the evaluated run
+ *  - lr: Learning rate used in the evaluated run
+ *  - rootEvery: rootEvery used in the evaluated run
+ *  - preconEvery: preconEvery used in the evaluated run
+ *
+ * Output:
+ *  - L: Updated tuning log matrix (with row `run` filled)
+ */
+    L[run,1] = as.double(roundID)
+    L[run,2] = as.double(paramID)
+    L[run,3] = candidate
+    L[run,4] = loss
+    L[run,5] = epsilon
+    L[run,6] = lr
+    L[run,7] = as.double(rootEvery)
+    L[run,8] = as.double(preconEvery)
+}
+
+startHyperparameterTuning = function(string type, string datasetName, list[unknown] epsilonList, list[unknown] lrList, list[unknown] rootEveryList, list[unknown] preconEveryList, 
+    double epsilon, double lr, int rootEvery, int preconEvery, int epochs, int rounds)
+    return(){
+    /*
+    * Runs multi-round sequential hyperparameter tuning for the selected training setup.
+    *
+    * The tuning procedure iterates for `rounds` rounds and evaluates candidate values
+    * from the provided lists. Within each round it tunes in sequence:
+    *  1: epsilon (always)
+    *  2: lr (always)
+    *  3: rootEvery (only if type == "finetuningShampooHeuristics")
+    *  4: preconEvery (only if type == "finetuningShampooHeuristics")
+    *
+    * For each candidate, it calls `runTraining(...)` (with optimizersToExperiment=1),
+    * logs the evaluation via `logRow(...)`, and keeps the candidate with the lowest loss.
+    *
+    * Inputs:
+    *  - type: Experiment mode ("finetuning" or "finetuningShampooHeuristics")
+    *  - datasetName: Dataset identifier (e.g., "mnist", "cifar")
+    *  - epsilonList: Candidate epsilons to test
+    *  - lrList: Candidate learning rates to test
+    *  - rootEveryList: Candidate rootEvery values to test (heuristic tuning only)
+    *  - preconEveryList: Candidate preconEvery values to test (heuristic tuning only)
+    *  - epsilon: Initial epsilon (starting point for tuning)
+    *  - lr: Initial learning rate (starting point for tuning)
+    *  - rootEvery: Initial rootEvery (starting point for tuning)
+    *  - preconEvery: Initial preconEvery (starting point for tuning)
+    *  - epochs: Number of epochs used per evaluation run
+    *  - rounds: Number of tuning rounds to perform
+    *
+    * Outputs:
+    *  - None (side effects: prints progress, runs training evaluations, and builds `tuningLog`).
+    *    At the end, `bestParams` contains the best found (epsilon, lr, rootEvery, preconEvery).
+    */
+    nEval = rounds * ( length(epsilonList) + length(lrList) + length(rootEveryList) + length(preconEveryList) )  
+    tuningLog = matrix(0, rows=nEval, cols=8)    
+    run = 0
+
+    for (round in 1:rounds) {
+        print("=== Round " + round + " ===")
+    
+        # tuning epsilon
+        bestLoss = 10000;
+        bestEpsilon = epsilon;
+
+        for (i in 1:length(epsilonList)) {
+            candidate = as.double(as.scalar(epsilonList[i]))
+            [loss, accuracy] = runTraining(type, candidate, lr, rootEvery, preconEvery, epochs, datasetName, 1)
+
+            run = run + 1
+            tuningLog = logRow(tuningLog, run, round, 1, candidate, loss, candidate, lr, rootEvery, preconEvery)
+
+            if (loss < bestLoss) {
+                bestLoss = loss
+                bestEpsilon = candidate
+            }
+        }
+
+        epsilon = bestEpsilon;
+        print("best epsilon = " + epsilon + " (loss=" + bestLoss + ")")
+
+        # tuning lr
+        bestLoss = 10000
+        bestLr = lr
+
+        for (i in 1:length(lrList)) {
+            candidate = as.double(as.scalar(lrList[i]))
+            [loss, accuracy] = runTraining(type, epsilon, candidate, rootEvery, preconEvery, epochs, datasetName, 1)
+
+            run = run + 1;
+            tuningLog = logRow(tuningLog, run, round, 2, candidate, loss, candidate, lr, rootEvery, preconEvery)
+
+            if (loss < bestLoss) {
+                bestLoss = loss
+                bestLr = candidate
+            }
+        }
+        lr = bestLr
+        print("best lr = " + lr + " (loss=" + bestLoss + ")")
+
+
+        if (type == "finetuningShampooHeuristics"){
+
+            # tuning rootEvery
+            bestLoss = 10000;
+            bestRoot = rootEvery;
+
+            for (i in 1:length(rootEveryList)) {
+                candidate = as.integer(as.scalar(rootEveryList[i]))
+                [loss, accuracy] = runTraining(type, epsilon, lr, candidate, preconEvery, epochs, datasetName, 1)
+
+                run = run + 1
+                tuningLog = logRow(tuningLog, run, round, 3, candidate, loss, candidate, lr, rootEvery, preconEvery)
+
+                if (loss < bestLoss) {
+                    bestLoss = loss
+                    bestRoot = candidate
+                }
+            }
+            rootEvery = bestRoot
+            print("best rootEvery = " + rootEvery + " (loss=" + bestLoss + ")")
+
+            # tuning preconEvery
+            bestLoss = 1e9;
+            bestPrecon = preconEvery;
+
+            for (i in 1:length(preconEveryList)) {
+                candidate = as.integer(as.scalar(preconEveryList[i]))
+                [loss, accuracy] = runTraining(type, epsilon, lr, rootEvery, candidate, epochs, datasetName, 1)
+
+                run = run + 1;
+                tuningLog = logRow(tuningLog, run, round, 4, candidate, loss, candidate, lr, rootEvery, preconEvery)
+
+                if (loss < bestLoss) {
+                    bestLoss = loss
+                    bestPrecon = candidate
+                }   
+            }
+            preconEvery = bestPrecon
+            print("best preconEvery = " + preconEvery + " (loss=" + bestLoss + ")")
+        }
+        print("Round " + round + " params: eps=" + epsilon + ", lr=" + lr +
+            ", rootEvery=" + rootEvery + ", preconEvery=" + preconEvery)
+    }
+    bestParams = list(epsilon, lr, rootEvery, preconEvery) 
+}
+
+
+
+#############################################################################################
+datasetName = "cifar" #Alternatives: "mnist" or "cifar"
+optimizersToExperiment = 9 # There are up to 9 optimizers available
+#############################################################################################
+# standard experiment
+loss = runTraining("training", 0, 0, 0, 0, 0, datasetName, optimizersToExperiment)
+
+
+#############################################################################################
+datasetName = "cifar" #Alternatives: "mnist" or "cifar"
+type = "finetuningShampooHeuristics" # "finetuning" or "finetuningShampooHeuristics"
+
+# finetuning list
+epsilonList =  list(0.09, 0.08, 0.07, 0.06, 0.05)
+lrList = list(0.5, 0.4, 0.3, 0.2) 
+rootEveryList = list(4, 8, 12)
+preconEveryList = list(2, 4)
+
+# standard values
+epsilon = 0.1
+lr = 0.3
+rootEvery = 4
+preconEvery = 2
+epochs = 30
+
+rounds = 2
+#############################################################################################
+# hyperparameter tuning
+# startHyperparameterTuning(type, datasetName, epsilonList, lrList, rootEveryList, preconEveryList, epsilon, lr, rootEvery, preconEvery, epochs, rounds)
\ No newline at end of file
diff --git a/scripts/staging/shampoo_optimizer/shampoo_optimizer_experiments_resnet.dml b/scripts/staging/shampoo_optimizer/shampoo_optimizer_experiments_resnet.dml
new file mode 100644
index 00000000000..ed91b3c2bc9
--- /dev/null
+++ b/scripts/staging/shampoo_optimizer/shampoo_optimizer_experiments_resnet.dml
@@ -0,0 +1,734 @@
+#-------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+#-------------------------------------------------------------
+
+source("scripts/nn/networks/resnet34.dml") as resnet34
+source("scripts/nn/networks/resnet18.dml") as resnet18
+
+source("scripts/nn/optim/shampoo.dml") as shampoo
+source("scripts/nn/optim/adagrad.dml") as adagrad
+source("scripts/nn/optim/adam.dml") as adam
+source("scripts/nn/layers/cross_entropy_loss.dml") as cross_entropy_loss
+source("scripts/nn/layers/softmax.dml") as softmax
+
+initShampooHelper = function(string optimizer, matrix[double] weights, double epsilon, int diagThreshold)
+    return(list[unknown] paramsOptimizerLayer) {
+    /*
+    * Initializes and packs the per-layer optimizer state for a Shampoo variant.
+    *
+    * Based on `optimizer`, this function calls the corresponding Shampoo initializer
+    * and returns a `paramsOptimizerLayer` list that contains all state needed for
+    * subsequent update steps.
+    *
+    * Inputs:
+    *  - optimizer: Shampoo variant identifier ("shampoo", "shampoo_momentum", "shampoo_heuristic")
+    *  - weights: Parameter matrix of the current layer
+    *  - epsilon: Numerical stability constant for preconditioner initialization
+    *  - diagThreshold: Dimension threshold controlling whether diagonal preconditioning is used
+    *
+    * Outputs:
+    *  - paramsOptimizerLayer: Optimizer state list for this layer, with layout depending on variant:
+    *      - "shampoo":
+    *          [preconL, preconR, useDiag]
+    *      - "shampoo_momentum":
+    *          [preconL, preconR, momentum, useDiag]
+    *      - "shampoo_heuristic":
+    *          [preconL, preconR, stepCounter, bufferL, bufferR, momentum,
+    *           preconLinvPowerRoot, preconRinvPowerRoot, useDiag]
+    */
+    if (optimizer=="shampoo") {
+        [preconL, preconR, useDiag] = shampoo::init(weights, epsilon, diagThreshold)
+        paramsOptimizerLayer = list(preconL, preconR, useDiag)
+    }
+    if (optimizer=="shampoo_momentum"){
+        [preconL, preconR, momentum, useDiag] = shampoo::init_momentum(weights, epsilon, diagThreshold)
+        paramsOptimizerLayer = list(preconL, preconR, momentum, useDiag)
+    }
+    if (optimizer=="shampoo_heuristic"){
+        [preconL, preconR, stepCounter, bufferL, bufferR, momentum, preconLinvPowerRoot, preconRinvPowerRoot, useDiag] = shampoo::init_heuristic(weights, epsilon, diagThreshold)
+        paramsOptimizerLayer = list(preconL, preconR, stepCounter, bufferL, bufferR, momentum, preconLinvPowerRoot, preconRinvPowerRoot, useDiag)
+    }
+}
+
+initShampooForModel = function(string optimizer, list[unknown] model, double epsilon, int diagThreshold)
+    /*
+    * Initializes Shampoo optimizer state for an entire ResNet-style model and
+    * returns it in a structure that mirrors the model's parameter layout.
+    *
+    * This function iterates over all model parameter groups:
+    *  - layers 1..3 (stem / early layers),
+    *  - residual layers 4..7 (each a list of blocks, each block a list of params),
+    *  - layers 8..9 (final fully-connected layers),
+    * and calls `initShampooHelper` for every parameter matrix.
+    *
+    * Inputs:
+    *  - optimizer: Shampoo variant identifier ("shampoo", "shampoo_momentum", "shampoo_heuristic")
+    *  - model: Model parameter list (ResNet-style layout)
+    *  - epsilon: Numerical stability constant for preconditioner initialization
+    *  - diagThreshold: Dimension threshold controlling whether diagonal preconditioning is used
+    *
+    * Outputs:
+    *  - paramsOptimizer: Nested list of optimizer states with the same outer indexing scheme as `model`.
+    */
+    return(list[unknown] paramsOptimizer) {
+
+    paramsOptimizerLayer1 = initShampooHelper(optimizer, as.matrix(model[1]), epsilon, diagThreshold)
+    paramsOptimizerLayer2 = initShampooHelper(optimizer, as.matrix(model[2]), epsilon, diagThreshold)
+    paramsOptimizerLayer3 = initShampooHelper(optimizer, as.matrix(model[3]), epsilon, diagThreshold)
+
+    # 4 to 7: residual layers (each is list of blocks)
+    residualLayersParams = list()   # will hold 4 entries
+
+    for(layerIndex in 4:7) {
+        layer = as.list(model[layerIndex])     # list of blocks
+        layer_blocks = list()
+
+        for(blockIndex in 1:length(layer)) {
+            blockParameters = as.list(layer[blockIndex])   # list of params in this block
+            parameters = list()
+
+            for(parameterIndex in 1:length(blockParameters)) {
+                parameter = as.matrix(blockParameters[parameterIndex])
+                tmp = initShampooHelper(optimizer, parameter, epsilon, diagThreshold)
+                parameters = append(parameters, tmp)
+            }
+
+            layer_blocks = append(layer_blocks, parameters)
+        }
+
+        residualLayersParams = append(residualLayersParams, layer_blocks)
+    }
+
+    # 8..9: fully connected
+    paramsOptimizerLayer8 = initShampooHelper(optimizer, as.matrix(model[8]), epsilon, diagThreshold)
+    paramsOptimizerLayer9 = initShampooHelper(optimizer, as.matrix(model[9]), epsilon, diagThreshold)
+
+    # pack state with same outer indexing scheme
+    paramsOptimizer = list(
+    paramsOptimizerLayer1, paramsOptimizerLayer2, paramsOptimizerLayer3,
+    as.list(residualLayersParams[1]), as.list(residualLayersParams[2]), as.list(residualLayersParams[3]), as.list(residualLayersParams[4]),
+    paramsOptimizerLayer8, paramsOptimizerLayer9
+    )
+}
+
+
+updateShampooHelper = function(string optimizer, matrix[double] weight, list[unknown] paramsOptimizerLayer, matrix[double] gradient, double lr, int rootEvery, int preconEvery)
+    return (matrix[double] updatedWeight, list[unknown] paramsOptimizerLayer){
+    /*
+    * Applies one Shampoo update step to a single parameter matrix and updates the
+    * corresponding optimizer state for the selected Shampoo variant.
+    *
+    * Depending on `optimizer`, this function dispatches to:
+    *  - shampoo::update (classic Shampoo),
+    *  - shampoo::update_momentum (Shampoo with momentum),
+    *  - shampoo::update_heuristic (heuristic variant with cached inverse roots and periodic updates).
+    *
+    * Inputs:
+    *  - optimizer: Shampoo variant identifier ("shampoo", "shampoo_momentum", "shampoo_heuristic")
+    *  - weight: Current parameter matrix to update
+    *  - paramsOptimizerLayer: Optimizer state for this parameter (layout depends on variant)
+    *  - gradient: Gradient matrix for `weight`
+    *  - lr: Learning rate
+    *  - rootEvery: (heuristic only) Frequency for recomputing inverse roots
+    *  - preconEvery: (heuristic only) Frequency for updating preconditioners
+    *
+    * Outputs:
+    *  - updatedWeight: Updated parameter matrix after one optimization step
+    *  - paramsOptimizerLayer: Updated optimizer state for this parameter, re-packed as a list
+    */
+    if (optimizer=="shampoo") {
+        preconL = as.matrix(paramsOptimizerLayer[1])
+        preconR = as.matrix(paramsOptimizerLayer[2])
+        useDiag = as.boolean(as.scalar(paramsOptimizerLayer[3]))
+        [updatedWeight, preconL, preconR] = shampoo::update(weight, gradient, lr, preconL, preconR, useDiag)
+        paramsOptimizerLayer = list(preconL, preconR, useDiag)
+    }
+    if (optimizer=="shampoo_momentum"){
+        preconL = as.matrix(paramsOptimizerLayer[1])
+        preconR = as.matrix(paramsOptimizerLayer[2])
+        momentum = as.matrix(paramsOptimizerLayer[3])
+        useDiag = as.boolean(as.scalar(paramsOptimizerLayer[4]))
+        [updatedWeight, preconL, preconR, momentum] = shampoo::update_momentum(weight, gradient, lr, preconL, preconR, momentum, useDiag)
+        paramsOptimizerLayer = list(preconL, preconR, momentum, useDiag)
+    }
+    if (optimizer=="shampoo_heuristic"){
+        preconL = as.matrix(paramsOptimizerLayer[1])
+        preconR = as.matrix(paramsOptimizerLayer[2])
+        stepCounter = as.integer(as.scalar(paramsOptimizerLayer[3]))
+        bufferL = as.matrix(paramsOptimizerLayer[4])
+        bufferR = as.matrix(paramsOptimizerLayer[5])
+        momentum = as.matrix(paramsOptimizerLayer[6])
+        preconLinvPowerRoot = as.matrix(paramsOptimizerLayer[7])
+        preconRinvPowerRoot = as.matrix(paramsOptimizerLayer[8])
+        useDiag = as.boolean(as.scalar(paramsOptimizerLayer[9]))
+        [updatedWeight, preconL, preconR, momentum, stepCounter, bufferL, bufferR, preconLinvPowerRoot, preconRinvPowerRoot] = shampoo::update_heuristic(weight, gradient, lr, preconL, preconR, momentum, stepCounter, rootEvery, preconEvery, bufferL, bufferR, preconLinvPowerRoot, preconRinvPowerRoot, useDiag)
+        paramsOptimizerLayer = list(preconL, preconR, stepCounter, bufferL, bufferR, momentum, preconLinvPowerRoot, preconRinvPowerRoot, useDiag)
+    }
+}
+
+
+updateShampooForModel = function(string optimizer, list[unknown] model, list[unknown] paramsOptimizer, list[unknown] gradients, double lr, int rootEvery, int preconEvery)
+    return(list[unknown] model, list[unknown] paramsOptimizer){
+    /*
+    * Applies a Shampoo update step to all parameters of a ResNet-style model and
+    * updates the corresponding optimizer state tree.
+    *
+    * The function iterates over:
+    *  - Top-level layers 1..3 (single matrices),
+    *  - Residual layers 4..7 (lists of blocks, each block is a list of parameter matrices),
+    *  - Fully connected layers 8..9 (single matrices),
+    * and calls `updateShampooHelper` for each parameter using the matching gradient
+    * and per-parameter optimizer state.
+    *
+    * Inputs:
+    *  - optimizer: Shampoo variant identifier ("shampoo", "shampoo_momentum", "shampoo_heuristic")
+    *  - model: Model parameter structure (same indexing scheme as ResNet init/forward/backward)
+    *  - paramsOptimizer: Optimizer state structure aligned with `model`
+    *  - gradients: Gradient structure aligned with `model`
+    *  - lr: Learning rate
+    *  - rootEvery: (heuristic only) Frequency for recomputing inverse roots
+    *  - preconEvery: (heuristic only) Frequency for updating preconditioners
+    *
+    * Outputs:
+    *  - model: Updated model parameters after applying one optimizer step
+    *  - paramsOptimizer: Updated optimizer state tree after applying one optimizer step
+    */
+
+    [updatedWeightLayer1, paramsOptimizerLayer1] = updateShampooHelper(optimizer, as.matrix(model[1]), as.list(paramsOptimizer[1]), as.matrix(gradients[1]), lr, rootEvery, preconEvery)
+    model[1] = updatedWeightLayer1
+    paramsOptimizer[1] = list(paramsOptimizerLayer1)
+    [updatedWeightLayer2, paramsOptimizerLayer2] = updateShampooHelper(optimizer, as.matrix(model[2]), as.list(paramsOptimizer[2]), as.matrix(gradients[2]), lr, rootEvery, preconEvery)
+    model[2] = updatedWeightLayer2
+    paramsOptimizer[2] = list(paramsOptimizerLayer2)
+    [updatedWeightLayer3, paramsOptimizerLayer3] = updateShampooHelper(optimizer, as.matrix(model[3]), as.list(paramsOptimizer[3]), as.matrix(gradients[3]), lr, rootEvery, preconEvery)
+    model[3] = updatedWeightLayer3
+    paramsOptimizer[3] = list(paramsOptimizerLayer3)
+
+    # 4 to 7: residual layers (each is list of blocks)
+    residualLayersParams = list()
+    residualLayersWeights = list()
+
+    for(layerIndex in 4:7) {
+        layerParameters = as.list(paramsOptimizer[layerIndex])
+        layerWeights = as.list(model[layerIndex])  
+        layerGradients = as.list(gradients[layerIndex])  
+
+        for(blockIndex in 1:length(layerParameters)) {
+            blockParameters = as.list(layerParameters[blockIndex])   # list of params in this block
+            blockWeights = as.list(layerWeights[blockIndex])
+            blockGradients = as.list(layerGradients[blockIndex])
+
+            for(parameterIndex in 1:length(blockParameters)) {
+                parameter = as.list(blockParameters[parameterIndex])
+                weight = as.matrix(blockWeights[parameterIndex])
+                gradient = as.matrix(blockGradients[parameterIndex])
+                [updatedWeight, updatedParameter] = updateShampooHelper(optimizer, weight, parameter, gradient, lr, rootEvery, preconEvery)
+
+                blockWeights[parameterIndex] = updatedWeight
+                blockParameters[parameterIndex] = list(updatedParameter)
+            }
+            layerWeights[blockIndex] = list(blockWeights)
+            layerParameters[blockIndex] = list(blockParameters)
+        }
+        model[layerIndex] = list(layerWeights)
+        paramsOptimizer[layerIndex] = list(layerParameters)
+    }
+
+    # 8..9: fully connected
+    [updatedWeightLayer8, paramsOptimizerLayer8]= updateShampooHelper(optimizer, as.matrix(model[8]), as.list(paramsOptimizer[8]), as.matrix(gradients[8]), lr, rootEvery, preconEvery)
+    model[8] = updatedWeightLayer8
+    paramsOptimizer[8] = list(paramsOptimizerLayer8)
+    [updatedWeightLayer9, paramsOptimizerLayer9] = updateShampooHelper(optimizer, as.matrix(model[9]), as.list(paramsOptimizer[9]), as.matrix(gradients[9]), lr, rootEvery, preconEvery)
+    model[9] = updatedWeightLayer9
+    paramsOptimizer[9] = list(paramsOptimizerLayer9)
+
+}
+
+addL2Regularization = function(list[unknown] model, list[unknown] gradients, double weightDecay)
+    return (list[unknown] gradients) {
+    /*
+    * Adds L2 regularization (weight decay) to a model's gradients in-place.
+    *
+    * For each eligible weight matrix W, the gradient is adjusted as:
+    *   G <- G + weightDecay * W
+    *
+    * The function applies weight decay to:
+    *  - Layer 1 (always),
+    *  - Residual layers 4..7 (all block parameters with nrow(W)>1 and ncol(W)>1),
+    *  - Layer 8 (always),
+    * and leaves bias-like parameters (vectors / 1D shapes) unchanged.
+    *
+    * Inputs:
+    *  - model: Model parameter structure (ResNet-style indexing)
+    *  - gradients: Gradient structure aligned with `model`
+    *  - weightDecay: L2 regularization coefficient
+    *
+    * Outputs:
+    *  - gradients: Updated gradients with weight decay added to selected parameters
+    */
+
+    g1 = as.matrix(gradients[1]) + weightDecay * as.matrix(model[1])
+    gradients[1] = g1
+
+    for(layerIndex in 4:7) {
+        layerWeights = as.list(model[layerIndex])
+        layerGrads = as.list(gradients[layerIndex])
+
+        for(blockIndex in 1:length(layerGrads)) {
+            blockWeights = as.list(layerWeights[blockIndex])
+            blockGrads = as.list(layerGrads[blockIndex])
+
+            for(paramIndex in 1:length(blockGrads)) {
+                W = as.matrix(blockWeights[paramIndex])
+                G = as.matrix(blockGrads[paramIndex])
+
+                if (nrow(W) > 1 & ncol(W) > 1) {
+                    g = G + weightDecay * W
+                    blockGrads[paramIndex] = g
+                } else {
+                    blockGrads[paramIndex] = G
+                }
+            }
+
+            layerGrads[blockIndex] = list(blockGrads)  
+        }
+
+        gradients[layerIndex] = list(layerGrads)   
+    }
+
+    g8 = as.matrix(gradients[8]) + weightDecay * as.matrix(model[8])
+    gradients[8] = g8
+}
+
+definingData = function(string datasetName)
+    return(matrix[double] XTrain, matrix[double] YTrain, matrix[double] XVal, matrix[double] YVal, matrix[double] XTest, matrix[double] YTest){
+    /*
+    * Loads and prepares train/validation/test splits for MNIST or CIFAR-10.
+    *
+    * MNIST:
+    *  - Reads `mnist_test.csv`, splits into train/test by row ranges.
+    *  - Normalizes pixel values to [0,1] by dividing by 255.
+    *  - Creates a validation set from the first 1000 training rows.
+    *  - One-hot encodes labels into 10 classes.
+    *
+    * CIFAR-10:
+    *  - Reads `cifar10.csv` (custom preprocessed CSV with label in column 1).
+    *  - Uses rows 1..20000 for training pool and 20001..30000 for test.
+    *  - Creates a validation set from the first 5000 training rows and
+    *    uses the remainder for training.
+    *  - One-hot encodes labels into 10 classes.
+    *  - Prints dataset size diagnostics (row counts and min/max for XTrain).
+    *
+    * Inputs:
+    *  - datasetName: "mnist" or "cifar"
+    *
+    * Outputs:
+    *  - XTrain, YTrain: Training features and one-hot labels
+    *  - XVal, YVal: Validation features and one-hot labels
+    *  - XTest, YTest: Test features and one-hot labels
+    */
+
+    if (datasetName=="mnist"){
+        data = read("src/test/resources/datasets/MNIST/mnist_test.csv", format="csv") 
+        train = data[1:8999,]
+        test = data[9000:nrow(data),] 
+
+        images = train[,2:ncol(train)]
+        images = images / 255.0
+        labels = train[,1]
+        imagesTest = test[,2:ncol(test)]
+        imagesTest = imagesTest / 255.0
+        labelsTest = test[,1]
+
+        N = nrow(images)
+        nTest = nrow(imagesTest)     
+
+        XTrain = images[1001:nrow(images),]
+        labelsTrain = labels[1001:nrow(images),]
+        YTrain = table(seq(1, nrow(XTrain)), labelsTrain+1, nrow(XTrain), 10)      
+
+        XVal = images[1:1000,]
+        labelsVal = labels[1:1000,]
+        YVal = table(seq(1, nrow(XVal)), labelsVal+1, nrow(XVal), 10)
+
+        XTest = imagesTest
+        YTest = table(seq(1, nTest), labelsTest+1, nTest, 10)
+    }
+    if (datasetName=="cifar"){
+        data = read("scripts/staging/shampoo_optimizer/cifar10.csv", format="csv")
+
+        train = data[1:20000,] 
+        test = data[20001:30000,]
+
+        images = train[,2:ncol(train)]
+        labels = train[,1]
+        imagesTest = test[,2:ncol(test)]
+        labelsTest = test[,1]
+
+        N = nrow(images)
+        nTest = nrow(imagesTest)     
+
+        XTrain = images[5001:nrow(images),]
+        labelsTrain = labels[5001:nrow(images),]
+        YTrain = table(seq(1, nrow(XTrain)), labelsTrain+1, nrow(XTrain), 10)      
+        XVal = images[1:5000,]
+        labelsVal = labels[1:5000,]
+        YVal = table(seq(1, nrow(XVal)), labelsVal+1, nrow(XVal), 10)
+
+        XTest = imagesTest
+        YTest = table(seq(1, nTest), labelsTest+1, nTest, 10)
+
+        #train = data[1:39999,]                              
+        #test = data[40000:nrow(data),]  
+
+        #images = train[,2:ncol(train)]
+        #images = images / 255.0
+        #labels = train[,1]
+        #imagesTest = test[,2:ncol(test)]
+        #labelsTest = test[,1]
+
+        #N = nrow(images)
+        #nTest = nrow(imagesTest)
+
+        #XTrain = images[5001:nrow(images),]                  
+        #labelsTrain = labels[5001:nrow(images),] 
+        #YTrain = table(seq(1, nrow(XTrain)), labelsTrain+1, nrow(XTrain), 10)
+
+        #XVal = images[1:5000,]          
+        #labelsVal = labels[1:5000,] 
+        #YVal = table(seq(1, nrow(XVal)), labelsVal+1, nrow(XVal), 10)
+
+        #XTest = imagesTest
+        #YTest = table(seq(1, nTest), labelsTest+1, nTest, 10)
+    }
+}
+
+# Define image properties
+
+definingImageProperties = function(string datasetName)
+    return(int hIn, int wIn, int cIn, int classes){
+    /*
+    * Returns basic image shape metadata for the selected dataset.
+    *
+    * Provides the input height/width, number of channels, and number of classes
+    * for the supported datasets.
+    *
+    * Inputs:
+    *  - datasetName: Dataset identifier ("mnist" or "cifar").
+    *
+    * Outputs:
+    *  - hIn: Input image height.
+    *  - wIn: Input image width.
+    *  - cIn: Number of input channels.
+    *  - classes: Number of classes.
+    */
+    if(datasetName=="mnist"){
+        hIn = 28       
+        wIn = 28       
+        cIn = 1        
+        classes = 10
+    } 
+    if(datasetName=="cifar"){
+        hIn = 32       
+        wIn = 32      
+        cIn = 3        
+        classes = 10
+    }
+}
+
+
+# Define training parameters
+definingTrainingParameters = function(string optimizer, string datasetName)
+    return(int epochs, int batchSize, double epsilon, double lr, int diagThreshold, int rootEvery, int preconEvery){
+    /*
+    * Returns training hyperparameters (epochs, batch size, and optimizer-specific settings)
+    * for a given optimizer and dataset.
+    *
+    * This function provides preset hyperparameters per optimizer (Adam, Adagrad, SGD,
+    * and three Shampoo variants) and per dataset ("mnist" vs "cifar").
+    *
+    * Inputs:
+    *  - optimizer: Optimizer name.
+    *  - datasetName: Dataset identifier ("mnist" or "cifar").
+    *
+    * Outputs:
+    *  - epochs: Number of training epochs.
+    *  - batchSize: Mini-batch size.
+    *  - epsilon: Numerical stability constant for the selected optimizer/dataset.
+    *  - lr: Learning rate for the selected optimizer/dataset.
+    *  - diagThreshold: Shampoo diagonalization threshold
+    *  - rootEvery: Frequency for computing matrix roots in Shampoo heuristic.
+    *  - preconEvery: Frequency for updating preconditioners in heuristic Shampoo.
+    */
+    lr = 0.001
+    if(optimizer=="adam"){
+        if(datasetName=="cifar"){
+            epsilon = 1e-7
+            lr = 5.0e-4 
+        }else{
+            epsilon = 1e-4
+            lr = 0.0015  
+        } 
+    } 
+    else if(optimizer=="adagrad"){
+        if(datasetName=="cifar"){
+            epsilon = 1.0e-5
+            lr = 0.007           
+        }else{
+            epsilon = 1e-5
+            lr = 0.002
+        }
+    } 
+    else if(optimizer=="sgd"){
+        if(datasetName=="cifar"){
+            epsilon = 1.0e-8
+            lr = 0.1    
+        }else{
+            epsilon = 1e-6
+            lr = 0.03              
+        }
+    } 
+    else if((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")){
+        if(datasetName=="cifar"){
+            epsilon = 0.09
+            lr = 0.2    
+        } else{
+            epsilon = 0.001
+            lr = 0.1   
+        }
+    } 
+    else if((optimizer == "shampoo_momentum") | (optimizer == "shampoo_momentum_diagonal")){
+        if(datasetName=="cifar"){
+            epsilon = 1.0e-7
+            lr = 0.3    
+        } else{
+            epsilon = 1e-4 
+            lr = 0.55    
+        }
+    } 
+    else if((optimizer == "shampoo") | (optimizer == "shampoo_diagonal")){
+        if(datasetName=="cifar"){
+            epsilon = 0.09
+            lr = 0.2    
+        } else{
+            epsilon = 0.2 
+            lr = 0.6    
+        }
+    } 
+
+    if(datasetName=="cifar"){
+        epochs = 200     
+    } else{
+        epochs = 30    
+    }
+    batchSize = 64
+    rootEvery = 8  
+    preconEvery = 2
+    if ((optimizer == "shampoo_diagonal") | (optimizer == "shampoo_momentum_diagonal") | (optimizer == "shampoo_heuristic_diagonal")){
+        diagThreshold = 1
+    } else{
+        diagThreshold = 1200
+    }
+}
+
+getOptimizer = function(int optimizerIndex)
+    return(string optimizer){
+    /*
+    * Maps an integer index to an optimizer name string used throughout the
+    * experiment pipeline.
+    *
+    * Inputs:
+    *  - optimizerIndex: Integer identifier of the optimizer (1..6)
+    *
+    * Outputs:
+    *  - optimizer: Optimizer name corresponding to the index.
+    */
+        if (optimizerIndex==1)
+        {
+            optimizer = "shampoo"
+        }
+        if (optimizerIndex==2)
+        {
+            optimizer = "shampoo_momentum"
+        }
+        if (optimizerIndex==3)
+        {
+            optimizer = "shampoo_heuristic"
+        }
+        if (optimizerIndex==4)
+        {
+            optimizer = "adam"
+        }
+        if (optimizerIndex==5)
+        {
+            optimizer = "sgd"
+        }
+        if (optimizerIndex==6)
+        {
+            optimizer = "adagrad"
+        }
+}
+
+# set parameters for the experiments
+#############################################################################################
+datasetName = "cifar" #Alternatives: "mnist" or "cifar"
+optimizersToExperiment = 6
+# Alternatives: ("shampoo", "shampoo_momentum", "shampoo_heuristic", "adam", "sgd", "adagrad")
+#############################################################################################
+
+
+for (optimizerIndex in 1:optimizersToExperiment){
+    optimizer = getOptimizer(optimizerIndex)
+    print("Starting with " + optimizer)
+    seed = 42
+    # get the data
+    [XTrain, YTrain, XVal, YVal, XTest, YTest] = definingData(datasetName)
+
+    # get image properties
+    [hIn, wIn, cIn, classes] = definingImageProperties(datasetName)
+
+    # get training parameters
+    [epochs, batchSize, epsilon, lr, diagThreshold, rootEvery, preconEvery]= definingTrainingParameters(optimizer, datasetName)
+
+    # init the model
+
+    [model, emas] = resnet18::init(classes, seed)
+
+    # init the optimizer
+
+    if ((optimizer  == "shampoo") | (optimizer == "shampoo_momentum") | (optimizer == "shampoo_heuristic")){
+        paramsOptimizer = initShampooForModel(optimizer, model, epsilon, diagThreshold)
+    }
+    if (optimizer  == "adam"){
+        paramsOptimizer = resnet18::init_adam_optim_params(classes)
+    }
+    if (optimizer  == "adagrad"){
+        paramsOptimizer = resnet18::init_adagrad_optim_params(classes)
+    }
+    if (optimizer  == "sgd"){
+        # not needed to init
+    }
+
+    trainLosses = matrix(0, rows=epochs, cols=1)
+    trainAccuracies = matrix(0, rows=epochs, cols=1)
+    valAccuracies = matrix(0, rows=epochs, cols=1)
+    valLosses = matrix(0, rows=epochs, cols=1)
+    Ntrain = nrow(XTrain)
+
+    # train the model
+    t = 0
+    for(epoch in 1:epochs){
+
+        print("Epoch " + epoch + " of " + epochs + " epochs")
+
+        accuracyValue = 0
+        accuracyCount = 0
+        lossValue = 0
+        lossCount = 0
+        
+        numBatches = as.integer(ceil(Ntrain / batchSize))
+        batchID = 0
+
+        for(startIndex in seq(1, Ntrain, batchSize)){
+            endIndex = min(startIndex + batchSize - 1, Ntrain)
+            dataTrainX = XTrain[startIndex:endIndex,]
+            dataTrainY = YTrain[startIndex:endIndex,]
+
+            batchID = batchID + 1
+            #print("Batch " + batchID + " of " + numBatches + " Batches")
+
+            [out, emas, cachedOut, cachedMeansVars] = resnet18::forward(dataTrainX, hIn, wIn, model, "train", emas)
+
+            predictedValue = rowIndexMax(out) - 1
+            accuracy = sum(predictedValue==rowIndexMax(dataTrainY)-1) / length(predictedValue)
+            accuracyValue = accuracyValue + accuracy
+            accuracyCount = accuracyCount + 1
+
+            probs = softmax::forward(out)
+            loss = cross_entropy_loss::forward(probs, dataTrainY)
+            dLossDProbs = cross_entropy_loss::backward(probs, dataTrainY)
+            dOut = softmax::backward(dLossDProbs, out)
+
+            lossValue = lossValue + loss
+            lossCount = lossCount + 1
+
+            [dX, gradients] = resnet18::backward(dOut, cachedOut, model, cachedMeansVars)
+
+
+            weightDecay = 1e-3
+            gradients = addL2Regularization(model, gradients, weightDecay)
+
+            # optimizing
+            if ((optimizer  == "shampoo") | (optimizer  == "shampoo_momentum") | (optimizer  == "shampoo_heuristic")){
+                [model, paramsOptimizer] = updateShampooForModel(optimizer, model, paramsOptimizer, gradients, lr, rootEvery, preconEvery)
+            }
+            if (optimizer  == "adam"){
+                [model, paramsOptimizer] = resnet18::update_params_with_adam(model, gradients, lr, 0.9, 0.999, 1e-8, t, paramsOptimizer)
+                t = t+1
+            }
+            if (optimizer  == "adagrad"){
+                [model, paramsOptimizer] = resnet18::update_params_with_adagrad(model, gradients, lr, epsilon, paramsOptimizer)
+            }
+            if (optimizer  == "sgd"){
+                model = resnet18::update_params_with_sgd(model, gradients, lr)
+            }
+        }
+
+        trainLosses[epoch,1] = lossValue / lossCount
+        trainAccuracies[epoch,1] = accuracyValue/accuracyCount
+
+        print("Train Loss of " + optimizer + " = " + (lossValue / lossCount))
+        print("Train Accuracy of " + optimizer + " = " + (accuracyValue/accuracyCount))
+
+        # val loss
+        [outVal, emaMeansVarsUpdVal, cachedOutVal, cachedMeansVarsVal] = resnet18::forward(XVal, hIn, wIn, model, "test", emas)
+
+        predictedValueVal = rowIndexMax(outVal) - 1
+        accuracyVal = sum(predictedValueVal==rowIndexMax(YVal)-1) / length(predictedValueVal)
+
+        valAccuracies[epoch,1] = accuracyVal
+        probsVal = softmax::forward(outVal)
+        loss = cross_entropy_loss::forward(probsVal, YVal)
+        valLosses[epoch,1] = loss
+        print("Val Loss of " + optimizer + " = " + loss)
+        print("Val Accuracy of " + optimizer + " = " + accuracyVal)
+
+    }
+
+    # define the testing
+
+    [outTest, emaMeansVarsUpdTest, cachedOutTest, cachedMeansVarsTest] = resnet18::forward(XTest, hIn, wIn, model, "test", emas)
+
+    predictedValue = rowIndexMax(outTest) - 1
+    accuracy = sum(predictedValue==rowIndexMax(YTest)-1) / length(predictedValue)
+
+    probs_test = softmax::forward(outTest)
+    loss = cross_entropy_loss::forward(probs_test, YTest)
+
+    outDir = "scripts/staging/shampoo_optimizer/metrics"
+    epochs = nrow(trainLosses)
+    epoch_col = seq(1, epochs)         
+    M = cbind(epoch_col, trainLosses, trainAccuracies, valLosses, valAccuracies)
+    write(M, outDir + "/metrics" + "_" + optimizer + "_" + datasetName + ".csv", format="csv")
+
+    print("Test Accuracy of " + optimizer + " on " + datasetName + " = " + accuracy)
+    print("Test Loss of " + optimizer + " on " + datasetName + " = " + loss)
+
+}
\ No newline at end of file
diff --git a/src/test/scripts/applications/nn/component/shampoo_test.dml b/src/test/scripts/applications/nn/component/shampoo_test.dml
new file mode 100644
index 00000000000..2ed90845261
--- /dev/null
+++ b/src/test/scripts/applications/nn/component/shampoo_test.dml
@@ -0,0 +1,437 @@
+#-------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+#-------------------------------------------------------------
+
+source("scripts/nn/optim/shampoo.dml") as shampoo
+source("scripts/nn/optim/adagrad.dml") as adagrad
+source("scripts/nn/optim/adam.dml") as adam
+
+source("scripts/nn/layers/conv2d_builtin.dml") as conv2d
+source("scripts/nn/layers/avg_pool2d_builtin.dml") as avg_pool2d
+source("scripts/nn/layers/relu.dml") as relu
+source("scripts/nn/layers/cross_entropy_loss.dml") as cross_entropy_loss
+source("scripts/nn/layers/softmax.dml") as softmax
+
+
+
+# defining forward pass
+modelPredict = function(matrix[double] X, matrix[double] W1, matrix[double] b1, matrix[double] W2, matrix[double] b2, matrix[double] W_fc, matrix[double] b_fc, list[unknown] h_ins, list[unknown] w_ins, list[unknown] c_ins)
+    return(matrix[double] softMaxOut, matrix[double] X, matrix[double] convOut1, matrix[double] poolOut1, matrix[double] reluOut1, matrix[double] convOut2, matrix[double] poolOut2, matrix[double] reluOut2, matrix[double] pred){ #
+        filters = 64
+        conv_kernel = 5
+        pool_kernel = 4
+        conv_padding = 2
+        pool_padding = 1
+
+        h_in = as.integer(as.scalar(h_ins[1]))
+        h_in_1 = as.integer(as.scalar(h_ins[2]))
+        h_in_2 = as.integer(as.scalar(h_ins[3]))
+        h_in_3 = as.integer(as.scalar(h_ins[4]))
+        h_in_4 = as.integer(as.scalar(h_ins[5]))
+
+        w_in = as.integer(as.scalar(w_ins[1]))
+        w_in_1 = as.integer(as.scalar(w_ins[2]))
+        w_in_2 = as.integer(as.scalar(w_ins[3]))
+        w_in_3 = as.integer(as.scalar(w_ins[4]))
+        w_in_4 = as.integer(as.scalar(w_ins[5]))
+
+        c_in = as.integer(as.scalar(c_ins[1]))
+        c_in_1 = as.integer(as.scalar(c_ins[2]))
+
+        # first block
+        [convOut1, Hout, Wout] = conv2d::forward(X, W1, b1, c_in, h_in, w_in, conv_kernel, conv_kernel, 1, 1, conv_padding, conv_padding)
+
+        [poolOut1, Hout, Wout] = avg_pool2d::forward(convOut1, c_in_1, h_in_1, w_in_1, pool_kernel, pool_kernel, 2, 2, pool_padding, pool_padding)
+
+        reluOut1 = relu::forward(poolOut1)
+
+        # second block
+        [convOut2, Hout, Wout] = conv2d::forward(reluOut1, W2, b2, c_in_1, h_in_2, w_in_2, conv_kernel, conv_kernel, 1, 1, conv_padding, conv_padding)
+
+        [poolOut2, Hout, Wout] = avg_pool2d::forward(convOut2, c_in_1, h_in_3, w_in_3, pool_kernel, pool_kernel, 2, 2, pool_padding, pool_padding)
+
+        reluOut2 = relu::forward(poolOut2)
+
+        pred = reluOut2 %*% t(W_fc) + t(b_fc)
+
+        softMaxOut = softmax::forward(pred)
+
+        #Xs = list(X, convOut1, poolOut1, reluOut1, convOut2, poolOut2, reluOut2, pred, softMaxOut)
+
+    }
+
+#defining backward pass
+modelBackward = function(matrix[double] target, matrix[double] W1, matrix[double] b1, matrix[double] W2, matrix[double] b2, matrix[double] W_fc, matrix[double] b_fc, list[unknown] h_ins, list[unknown] w_ins, list[unknown] c_ins, matrix[double] X, matrix[double] convOut1, matrix[double] poolOut1, matrix[double] reluOut1, matrix[double] convOut2, matrix[double] poolOut2, matrix[double] reluOut2, matrix[double] pred, matrix[double] softMaxOut)
+    return (matrix[double] gradient_lin_layer_W, matrix[double] gradient_lin_layer_b, matrix[double] gradient_W2, matrix[double] gradient_b2, matrix[double] gradient_W1, matrix[double] gradient_b1){
+        filters = 64
+        conv_kernel = 5
+        pool_kernel = 4
+        conv_padding = 2
+        pool_padding = 1
+
+        h_in = as.integer(as.scalar(h_ins[1]))
+        h_in_1 = as.integer(as.scalar(h_ins[2]))
+        h_in_2 = as.integer(as.scalar(h_ins[3]))
+        h_in_3 = as.integer(as.scalar(h_ins[4]))
+        h_in_4 = as.integer(as.scalar(h_ins[5]))
+
+        w_in = as.integer(as.scalar(w_ins[1]))
+        w_in_1 = as.integer(as.scalar(w_ins[2]))
+        w_in_2 = as.integer(as.scalar(w_ins[3]))
+        w_in_3 = as.integer(as.scalar(w_ins[4]))
+        w_in_4 = as.integer(as.scalar(w_ins[5]))
+
+        c_in = as.integer(as.scalar(c_ins[1]))
+        c_in_1 = as.integer(as.scalar(c_ins[2]))
+
+        # gradient of loss function
+        gradient_lossfn = cross_entropy_loss::backward(softMaxOut, target)
+
+        # gradient Softmax
+        gradient_softmax = softmax::backward(gradient_lossfn, pred)
+
+        # gradients Linear layer
+        gradient_lin_layer_W = t(gradient_softmax) %*% reluOut2
+        gradient_lin_layer_b = t(colSums(gradient_softmax))
+        gradient_lin_layer_X = gradient_softmax %*% W_fc
+
+        # gradient second Relu
+        gradient_relu = relu::backward(gradient_lin_layer_X, poolOut2)
+
+        # gradient second pooling layer
+        gradient_second_pooling = avg_pool2d::backward(gradient_relu, h_in_4, w_in_4, convOut2, c_in_1, h_in_3, w_in_3, pool_kernel, pool_kernel, 2, 2, pool_padding, pool_padding)
+
+        # gradient second conv layer
+        [gradient_second_conv_X, gradient_W2, gradient_b2] = conv2d::backward(gradient_second_pooling, h_in_3, w_in_3, reluOut1, W2, b2, c_in_1, h_in_2, w_in_2, conv_kernel, conv_kernel, 1, 1, conv_padding, conv_padding)
+
+        # gradient of the first Relu
+        gradient_relu = relu::backward(gradient_second_conv_X, poolOut1)
+
+        # gradient first pooling layer
+        gradient_first_pooling = avg_pool2d::backward(gradient_relu, h_in_2, w_in_2, convOut1, c_in_1, h_in_1, w_in_1, pool_kernel, pool_kernel, 2, 2, pool_padding, pool_padding)
+
+        # gradient first conv layer
+        [gradient_first_conv_X, gradient_W1, gradient_b1] = conv2d::backward(gradient_first_pooling, h_in_1, w_in_1, X, W1, b1, c_in, h_in, w_in, conv_kernel, conv_kernel, 1, 1, conv_padding, conv_padding)
+
+    }
+
+
+definingData = function()
+    return(matrix[double] X_train, matrix[double] Y_train, matrix[double] X_val, matrix[double] Y_val, matrix[double] X_test, matrix[double] Y_test){
+
+    data = read("src/test/resources/datasets/MNIST/mnist_test.csv", format="csv") 
+    train = data[1:8999,]
+    test = data[9000:nrow(data),] 
+
+    images = train[,2:ncol(train)]
+    images = images / 255.0
+    labels = train[,1]
+    images_test = test[,2:ncol(test)]
+    labels_test = test[,1]
+
+    N = nrow(images)
+    N_test = nrow(images_test)     
+
+    X_train = images[1001:nrow(images),]
+    labels_train = labels[1001:nrow(images),]
+    Y_train = table(seq(1, nrow(X_train)), labels_train+1, nrow(X_train), 10)      
+
+    X_val = images[1:1000,]
+    labels_val = labels[1:1000,]
+    Y_val = table(seq(1, nrow(X_val)), labels_val+1, nrow(X_val), 10)
+
+    X_test = images_test
+    Y_test = table(seq(1, N_test), labels_test+1, N_test, 10)
+}
+
+# Define image properties
+
+defining_image_properties = function()
+    return(int h_in, int w_in, int c_in, int classes){
+
+    h_in = 28       
+    w_in = 28       
+    c_in = 1        
+    classes = 10
+
+}
+
+# Define training parameters
+defining_training_parameters = function(string optimizer)
+    return(int epochs, int batch_size, double epsilon, double lr, int rootEvery, int preconEvery){
+    
+    if ((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")){
+        epochs = 30
+        batch_size = 64
+        epsilon = 1e-4
+        lr = 0.005 
+        rootEvery = 10  
+        preconEvery = 2
+    }else{
+        epochs = 30
+        batch_size = 64
+        epsilon = 1e-4
+        lr = 0.005 
+        rootEvery = 0  
+        preconEvery = 0
+    }
+}
+
+defining_model_parameters = function()
+    return(int filters, int conv_kernel, int pool_kernel, int conv_padding, int pool_padding, int seed){
+    
+    filters = 64
+    conv_kernel = 5
+    pool_kernel = 4
+    conv_padding = 2
+    pool_padding = 1
+    seed = 42    
+}
+
+# create simple nn for image classification
+defining_nn_image_classification = function(int h_in, int w_in, int c_in, int classes, int filters, int conv_kernel, int pool_kernel, int conv_padding, int pool_padding, int seed)
+    return(list[unknown] h_ins, list[unknown] w_ins, list[unknown] c_ins, matrix[double] W1, matrix[double] b1, matrix[double] W2, matrix[double] b2, matrix[double] W_fc, matrix[double] b_fc){
+
+    # convolution layer 1
+    [W1, b1] = conv2d::init(filters, c_in, conv_kernel, conv_kernel, seed)
+    h_in_1 = h_in + conv_padding*2 - (conv_kernel - 1)
+    w_in_1 = w_in + conv_padding*2 - (conv_kernel - 1)
+    c_in_1 = filters
+    # pooling
+    h_in_2 = floor((h_in_1 + pool_padding*2 - pool_kernel)/2)+1
+    w_in_2 = floor((w_in_1 + pool_padding*2 - pool_kernel)/2)+1
+    # relu
+
+    # convolution layer 2
+    [W2, b2] = conv2d::init(filters, c_in_1, conv_kernel, conv_kernel, seed)
+    h_in_3 = h_in_2 + conv_padding*2 - (conv_kernel - 1)
+    w_in_3 = w_in_2 + conv_padding*2 - (conv_kernel - 1)
+    c_in_1 = filters
+    # pooling
+    h_in_4 = floor((h_in_3 + pool_padding*2 - pool_kernel)/2)+1
+    w_in_4 = floor((w_in_3 + pool_padding*2 - pool_kernel)/2)+1
+    # relu
+
+    # Linear
+    W_fc = rand(rows=classes, cols=h_in_4*w_in_4*c_in_1, pdf="uniform", min=-0.1, max=0.1, seed=seed)
+    b_fc = matrix(0, rows=classes, cols=1)
+
+    h_ins = list(h_in, h_in_1, h_in_2, h_in_3, h_in_4)
+    w_ins = list(w_in, w_in_1, w_in_2, w_in_3, w_in_4)
+    c_ins = list(c_in, c_in_1)    
+}
+
+get_optimizer = function(int optimizer_index)
+    return(string optimizer){
+
+        if (optimizer_index==1)
+        {
+            optimizer = "shampoo"
+        }
+        if (optimizer_index==2)
+        {
+            optimizer = "shampoo_diagonal"
+        }
+        if (optimizer_index==3)
+        {
+            optimizer = "shampoo_momentum"
+        }
+       if (optimizer_index==4)
+        {
+            optimizer = "shampoo_momentum_diagonal"
+        }
+        if (optimizer_index==5)
+        {
+            optimizer = "shampoo_heuristic"
+        }
+        if (optimizer_index==6)
+        {
+            optimizer = "shampoo_heuristic_diagonal"
+        }
+}
+
+# set parameters for the tests
+#############################################################################################
+optimizers_to_experiment = list("shampoo", "shampoo_diagonal", "shampoo_momentum", 
+            "shampoo_momentum_diagonal", "shampoo_heuristic", "shampoo_heuristic_diagonal")
+#############################################################################################
+
+for (optimizer_index in 1:length(optimizers_to_experiment)){
+    optimizer = get_optimizer(optimizer_index)
+    print("Starting with " + optimizer)
+
+    # get the data
+    [X_train, Y_train, X_val, Y_val, X_test, Y_test] = definingData()
+
+    # get image properties
+    [h_in, w_in, c_in, classes] = defining_image_properties()
+
+    # get model parameters
+    [filters, conv_kernel, pool_kernel, conv_padding, pool_padding, seed] = defining_model_parameters()
+
+    #get model weights
+    [h_ins, w_ins, c_ins, W1, b1, W2, b2, W_fc, b_fc] = defining_nn_image_classification(h_in, w_in, c_in, classes, filters, conv_kernel, pool_kernel, conv_padding, pool_padding, seed)
+
+    # get training parameters
+    [epochs, batch_size, epsilon, lr, rootEvery, preconEvery]= defining_training_parameters(optimizer)
+
+
+    if ((optimizer == "shampoo") | (optimizer == "shampoo_momentum") | (optimizer == "shampoo_heuristic")){
+        diagThreshold = 1200
+    }else{
+        diagThreshold = 1
+    }
+
+    if ((optimizer == "shampoo") | (optimizer == "shampoo_diagonal")){
+        [preconL_W1, preconR_W1, useDiag_W1] = shampoo::init(W1, epsilon, diagThreshold)
+        [preconL_b1, preconR_b1, useDiag_b1] = shampoo::init(b1, epsilon, diagThreshold)
+        [preconL_W2, preconR_W2, useDiag_W2] = shampoo::init(W2, epsilon, diagThreshold)
+        [preconL_b2, preconR_b2, useDiag_b2] = shampoo::init(b2, epsilon, diagThreshold)
+        [preconL_W_fc, preconR_W_fc, useDiag_W_fc] = shampoo::init(W_fc, epsilon, diagThreshold)
+        [preconL_b_fc, preconR_b_fc, useDiag_b_fc] = shampoo::init(b_fc, epsilon, diagThreshold)
+    }
+
+    if ((optimizer == "shampoo_momentum") | (optimizer == "shampoo_momentum_diagonal")){
+        [preconL_W1, preconR_W1, momentum_W1, useDiag_W1] = shampoo::init_momentum(W1, epsilon, diagThreshold)
+        [preconL_b1, preconR_b1, momentum_b1, useDiag_b1] = shampoo::init_momentum(b1, epsilon, diagThreshold)
+        [preconL_W2, preconR_W2, momentum_W2, useDiag_W2] = shampoo::init_momentum(W2, epsilon, diagThreshold)
+        [preconL_b2, preconR_b2, momentum_b2, useDiag_b2] = shampoo::init_momentum(b2, epsilon, diagThreshold)
+        [preconL_W_fc, preconR_W_fc, momentum_W_fc, useDiag_W_fc] = shampoo::init_momentum(W_fc, epsilon, diagThreshold)
+        [preconL_b_fc, preconR_b_fc, momentum_b_fc, useDiag_b_fc] = shampoo::init_momentum(b_fc, epsilon, diagThreshold)
+    }
+    if ((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")){
+        [preconL_W1, preconR_W1, stepCounter_W1, bufferL_W1, bufferR_W1, momentum_W1, preconLInvPowerRoot_W1, preconRInvPowerRoot_W1, useDiag_W1] = shampoo::init_heuristic(W1, epsilon, diagThreshold)
+        [preconL_b1, preconR_b1, stepCounter_b1, bufferL_b1, bufferR_b1, momentum_b1, preconLInvPowerRoot_b1, preconRInvPowerRoot_b1, useDiag_b1] = shampoo::init_heuristic(b1, epsilon, diagThreshold)
+        [preconL_W2, preconR_W2, stepCounter_W2, bufferL_W2, bufferR_W2, momentum_W2, preconLInvPowerRoot_W2, preconRInvPowerRoot_W2, useDiag_W2] = shampoo::init_heuristic(W2, epsilon, diagThreshold)
+        [preconL_b2, preconR_b2, stepCounter_b2, bufferL_b2, bufferR_b2, momentum_b2, preconLInvPowerRoot_b2, preconRInvPowerRoot_b2, useDiag_b2] = shampoo::init_heuristic(b2, epsilon, diagThreshold)
+        [preconL_W_fc, preconR_W_fc, stepCounter_W_fc, bufferL_W_fc, bufferR_W_fc, momentum_W_fc, preconLInvPowerRoot_W_fc, preconRInvPowerRoot_W_fc, useDiag_W_fc] = shampoo::init_heuristic(W_fc, epsilon, diagThreshold)
+        [preconL_b_fc, preconR_b_fc, stepCounter_b_fc, bufferL_b_fc, bufferR_b_fc, momentum_b_fc, preconLInvPowerRoot_b_fc, preconRInvPowerRoot_b_fc, useDiag_b_fc] = shampoo::init_heuristic(b_fc, epsilon, diagThreshold)
+    }
+    print(useDiag_W1)
+    print(useDiag_b1)
+    print(useDiag_W2)
+    print(useDiag_b2)
+    print(useDiag_W_fc)
+    print(useDiag_b_fc)
+    data_val_X = X_val
+    data_val_Y = Y_val
+
+    # define the training
+
+    train_losses = matrix(0, rows=epochs, cols=1)
+    train_accuracies = matrix(0, rows=epochs, cols=1)
+    val_accuracies = matrix(0, rows=epochs, cols=1)
+    val_losses = matrix(0, rows=epochs, cols=1)
+    Ntrain = nrow(X_train)
+
+    timestep = 0
+
+    for(epoch in 1:epochs){
+
+        print("Epoch " + epoch + " of " + epochs + " epochs")
+
+        accuracy_value = 0
+        accuracy_count = 0
+        loss_value = 0
+        loss_count = 0
+        
+
+        for(start_index in seq(1, Ntrain, batch_size)){
+            #start_index = (i - 1) * batch_size + 1
+            end_index = min(start_index + batch_size - 1, Ntrain)
+            data_train_X = X_train[start_index:end_index,]
+            data_train_Y = Y_train[start_index:end_index,]
+
+            [softMaxOut, X, convOut1, poolOut1, reluOut1, convOut2, poolOut2, reluOut2, pred] = modelPredict(data_train_X, W1, b1, W2, b2, W_fc, b_fc, h_ins, w_ins, c_ins)
+
+            predicted_value = rowIndexMax(softMaxOut) - 1
+            accuracy = sum(predicted_value==rowIndexMax(data_train_Y)-1) / length(predicted_value)
+            accuracy_value = accuracy_value + accuracy
+            accuracy_count = accuracy_count + 1
+
+            loss = cross_entropy_loss::forward(softMaxOut, data_train_Y)
+            loss_value = loss_value + loss
+            loss_count = loss_count + 1
+            
+
+            [gradient_lin_layer_W, gradient_lin_layer_b, gradient_W2, rootEvery, preconEveryadient_b2, gradient_W1, gradient_b1] = modelBackward(data_train_Y, W1, b1, W2, b2, W_fc, b_fc, h_ins, w_ins, c_ins, X, convOut1, poolOut1, reluOut1, convOut2, poolOut2, reluOut2, pred, softMaxOut)
+
+            if ((optimizer == "shampoo") | (optimizer == "shampoo_diagonal")){
+                [W1, preconL_W1, preconR_W1] = shampoo::update(W1, gradient_W1, lr, preconL_W1, preconR_W1, useDiag_W1)
+                [b1, preconL_b1, preconR_b1] = shampoo::update(b1, gradient_b1, lr, preconL_b1, preconR_b1, useDiag_b1)
+                [W2, preconL_W2, preconR_W2] = shampoo::update(W2, gradient_W2, lr, preconL_W2, preconR_W2, useDiag_W2)
+                [b2, preconL_b2, preconR_b2] = shampoo::update(b2, gradient_b2, lr, preconL_b2, preconR_b2, useDiag_b2)
+                [W_fc, preconL_W_fc, preconR_W_fc] = shampoo::update(W_fc, gradient_lin_layer_W, lr, preconL_W_fc, preconR_W_fc, useDiag_W_fc)
+                [b_fc, preconL_b_fc, preconR_b_fc] = shampoo::update(b_fc, gradient_lin_layer_b, lr, preconL_b_fc, preconR_b_fc, useDiag_b_fc)
+            }
+            if ((optimizer == "shampoo_momentum") | (optimizer == "shampoo_momentum_diagonal")){
+                [W1, preconL_W1, preconR_W1, momentum_W1] = shampoo::update_momentum(W1, gradient_W1, lr, preconL_W1, preconR_W1, momentum_W1, useDiag_W1)
+                [b1, preconL_b1, preconR_b1, momentum_b1] = shampoo::update_momentum(b1, gradient_b1, lr, preconL_b1, preconR_b1, momentum_b1, useDiag_b1)
+                [W2, preconL_W2, preconR_W2, momentum_W2] = shampoo::update_momentum(W2, gradient_W2, lr, preconL_W2, preconR_W2, momentum_W2, useDiag_W2)
+                [b2, preconL_b2, preconR_b2, momentum_b2] = shampoo::update_momentum(b2, gradient_b2, lr, preconL_b2, preconR_b2, momentum_b2, useDiag_b2)
+                [W_fc, preconL_W_fc, preconR_W_fc, momentum_W_fc] = shampoo::update_momentum(W_fc, gradient_lin_layer_W, lr, preconL_W_fc, preconR_W_fc, momentum_W_fc, useDiag_W_fc)
+                [b_fc, preconL_b_fc, preconR_b_fc, momentum_b_fc] = shampoo::update_momentum(b_fc, gradient_lin_layer_b, lr, preconL_b_fc, preconR_b_fc, momentum_b_fc, useDiag_b_fc)
+            }
+            if ((optimizer == "shampoo_heuristic") | (optimizer == "shampoo_heuristic_diagonal")){
+                [W1, preconL_W1, preconR_W1, momentum_W1, stepCounter_W1, bufferL_W1, bufferR_W1, preconLInvPowerRoot_W1, preconRInvPowerRoot_W1] = shampoo::update_heuristic(W1, gradient_W1, lr, preconL_W1, preconR_W1, momentum_W1, stepCounter_W1, rootEvery, preconEvery, bufferL_W1, bufferR_W1, preconLInvPowerRoot_W1, preconRInvPowerRoot_W1, useDiag_W1)
+                [b1, preconL_b1, preconR_b1, momentum_b1, stepCounter_b1, bufferL_b1, bufferR_b1, preconLInvPowerRoot_b1, preconRInvPowerRoot_b1] = shampoo::update_heuristic(b1, gradient_b1, lr, preconL_b1, preconR_b1, momentum_b1, stepCounter_b1, rootEvery, preconEvery, bufferL_b1, bufferR_b1, preconLInvPowerRoot_b1, preconRInvPowerRoot_b1, useDiag_b1)
+                [W2, preconL_W2, preconR_W2, momentum_W2, stepCounter_W2, bufferL_W2, bufferR_W2, preconLInvPowerRoot_W2, preconRInvPowerRoot_W2] = shampoo::update_heuristic(W2, gradient_W2, lr, preconL_W2, preconR_W2, momentum_W2, stepCounter_W2, rootEvery, preconEvery, bufferL_W2, bufferR_W2, preconLInvPowerRoot_W2, preconRInvPowerRoot_W2, useDiag_W2)
+                [b2, preconL_b2, preconR_b2, momentum_b2, stepCounter_b2, bufferL_b2, bufferR_b2, preconLInvPowerRoot_b2, preconRInvPowerRoot_b2] = shampoo::update_heuristic(b2, gradient_b2, lr, preconL_b2, preconR_b2, momentum_b2, stepCounter_b2, rootEvery, preconEvery, bufferL_b2, bufferR_b2, preconLInvPowerRoot_b2, preconRInvPowerRoot_b2, useDiag_b2)
+                [W_fc, preconL_W_fc, preconR_W_fc, momentum_W_fc, stepCounter_W_fc, bufferL_W_fc, bufferR_W_fc, preconLInvPowerRoot_W_fc, preconRInvPowerRoot_W_fc] = shampoo::update_heuristic(W_fc, gradient_lin_layer_W, lr, preconL_W_fc, preconR_W_fc, momentum_W_fc, stepCounter_W_fc, rootEvery, preconEvery, bufferL_W_fc, bufferR_W_fc, preconLInvPowerRoot_W_fc, preconRInvPowerRoot_W_fc, useDiag_W_fc)
+                [b_fc, preconL_b_fc, preconR_b_fc, momentum_b_fc, stepCounter_b_fc, bufferL_b_fc, bufferR_b_fc, preconLInvPowerRoot_b_fc, preconRInvPowerRoot_b_fc] = shampoo::update_heuristic(b_fc, gradient_lin_layer_b, lr, preconL_b_fc, preconR_b_fc, momentum_b_fc, stepCounter_b_fc, rootEvery, preconEvery, bufferL_b_fc, bufferR_b_fc, preconLInvPowerRoot_b_fc, preconRInvPowerRoot_b_fc, useDiag_b_fc)
+            }
+        }
+
+        train_losses[epoch,1] = loss_value / loss_count
+        train_accuracies[epoch,1] = accuracy_value/accuracy_count
+
+        [softMaxOut_val, X_val, convOut1_val, poolOut1_val, reluOut1_val, convOut2_val, poolOut2_val, reluOut2_val, pred_val] = modelPredict(X_val, W1, b1, W2, b2, W_fc, b_fc, h_ins, w_ins, c_ins)
+
+
+        predicted_value_val = rowIndexMax(softMaxOut_val) - 1
+        accuracy_val = sum(predicted_value_val==rowIndexMax(Y_val)-1) / length(predicted_value_val)
+
+        val_accuracies[epoch,1] = accuracy_val
+
+        loss = cross_entropy_loss::forward(softMaxOut_val, Y_val)
+        val_losses[epoch,1] = loss
+    }
+
+
+    # define the testing
+
+    [softMaxOut_test, X_test, convOut1_test, poolOut1_test, reluOut1_test, convOut2_test, poolOut2_test, reluOut2_test, pred_test] = modelPredict(X_test, W1, b1, W2, b2, W_fc, b_fc, h_ins, w_ins, c_ins)
+
+    predicted_value = rowIndexMax(softMaxOut_test) - 1
+    accuracy = sum(predicted_value==rowIndexMax(Y_test)-1) / length(predicted_value)
+
+    loss = cross_entropy_loss::forward(softMaxOut_test, Y_test)
+
+    print("Test Accuracy of " + optimizer + " = " + accuracy)
+    print("Test Loss of " + optimizer + " = " + loss)
+
+    if (accuracy > 0.7){
+        print("Test passed")
+    } else{
+        print("Test failed")
+    }
+
+}
+
diff --git a/src/test/scripts/applications/nn/component/shampoo_test.py b/src/test/scripts/applications/nn/component/shampoo_test.py
new file mode 100644
index 00000000000..c2815090615
--- /dev/null
+++ b/src/test/scripts/applications/nn/component/shampoo_test.py
@@ -0,0 +1,260 @@
+#-------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+#-------------------------------------------------------------
+
+import numpy as np
+from systemds.context import SystemDSContext
+
+# update shampoo 
+def update_shampoo(X, dX, lr, preconL, preconR, useDiag):
+    if(not useDiag):
+
+        preconL = preconL + dX @ dX.T
+        preconR = preconR + dX.T @dX
+
+        LEigenvalue, LEigenvector = np.linalg.eig(preconL)
+        preconLInvPowerRoot = LEigenvector @ np.diag(LEigenvalue**(-0.25)) @ LEigenvector.T
+
+        REigenvalue, REigenvector = np.linalg.eig(preconR)
+        preconRInvPowerRoot = REigenvector @ np.diag(REigenvalue**(-0.25)) @ REigenvector.T
+
+        X = X - lr * preconLInvPowerRoot @ dX @ preconRInvPowerRoot
+  
+  # Diagonal Shampoo:
+  # Memory-efficient approximation for large parameter matrices
+    else:
+        n = dX.shape[0]
+        m = dX.shape[1]
+
+        preconL = preconL + (dX**2).sum(axis=1, keepdims=True)          
+        preconR = preconR + (dX**2).sum(axis=0, keepdims=True)
+
+        preconLScale = preconL**(-0.25)        
+        preconRScale = preconR**(-0.25)
+
+        preconLMatrix = preconLScale @ np.ones(shape=[1, m])
+        preconRMatrix = np.ones(shape=(n, 1)) @ preconRScale
+
+        scaledGrad = dX * preconLMatrix
+        scaledGrad = scaledGrad * preconRMatrix
+
+        X = X - lr * scaledGrad
+
+    return(X, preconL, preconR)
+
+# init shampoo
+
+def init_shampoo(X, epsilon, useDiagThreshold):
+    if((X.shape[0] > useDiagThreshold) or (X.shape[1] > useDiagThreshold)):
+        preconL = np.full(shape=(X.shape[0], 1), fill_value=epsilon, dtype=np.float64)
+        preconR = np.full(shape=(1, X.shape[1]), fill_value=epsilon, dtype=np.float64)
+        useDiag = True
+    else:
+        preconL = np.eye(X.shape[0], dtype=np.float64) * epsilon
+        preconR = np.eye(X.shape[1], dtype=np.float64) * epsilon
+
+        useDiag = False
+    return(preconL, preconR, useDiag)
+
+# update shampoo 
+def update_shampoo_momentum(X, dX, lr, preconL, preconR, momentum, useDiag):
+    momentum = 0.9 * momentum + (0.1)*dX
+    if(not useDiag):
+
+        preconL = preconL + dX @ dX.T
+        preconR = preconR + dX.T @dX
+
+        LEigenvalue, LEigenvector = np.linalg.eig(preconL)
+        preconLInvPowerRoot = LEigenvector @ np.diag(LEigenvalue**(-0.25)) @ LEigenvector.T
+
+        REigenvalue, REigenvector = np.linalg.eig(preconR)
+        preconRInvPowerRoot = REigenvector @ np.diag(REigenvalue**(-0.25)) @ REigenvector.T
+
+        X = X - lr * preconLInvPowerRoot @ momentum @ preconRInvPowerRoot
+  
+  # Diagonal Shampoo:
+  # Memory-efficient approximation for large parameter matrices
+    else:
+        n = dX.shape[0]
+        m = dX.shape[1]
+
+        preconL = preconL + (dX**2).sum(axis=1, keepdims=True)          
+        preconR = preconR + (dX**2).sum(axis=0, keepdims=True)
+
+        preconLScale = preconL**(-0.25)        
+        preconRScale = preconR**(-0.25)
+
+        preconLMatrix = preconLScale @ np.ones(shape=[1, m])
+        preconRMatrix = np.ones(shape=(n, 1)) @ preconRScale
+
+        scaledGrad = momentum * preconLMatrix
+        scaledGrad = scaledGrad * preconRMatrix
+
+        X = X - lr * scaledGrad
+
+    return(X, preconL, preconR, momentum)
+
+# init shampoo
+
+def init_shampoo_momentum(X, epsilon, useDiagThreshold):
+    if((X.shape[0] > useDiagThreshold) or (X.shape[1] > useDiagThreshold)):
+        preconL = np.full(shape=(X.shape[0], 1), fill_value=epsilon, dtype=np.float64)
+        preconR = np.full(shape=(1, X.shape[1]), fill_value=epsilon, dtype=np.float64)
+        useDiag = True
+    else:
+        preconL = np.eye(X.shape[0], dtype=np.float64) * epsilon
+        preconR = np.eye(X.shape[1], dtype=np.float64) * epsilon
+
+        useDiag = False
+
+    momentum = X * 0
+    return(preconL, preconR, momentum, useDiag)
+
+# update shampoo 
+def update_shampoo_heuristic(X, dX, lr, preconL, preconR, momentum, stepCounter, rootEvery, preconEvery, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot, useDiag):
+    momentum = 0.9 * momentum + (0.1)*dX
+    if(not useDiag):
+        bufferL = bufferL + (dX @ dX.T)
+        bufferR = bufferR + (dX.T @dX)
+
+        if ((stepCounter > 0) and (stepCounter % preconEvery == 0)):
+            preconL = preconL + bufferL
+            preconR = preconR + bufferR
+            bufferL = bufferL * 0
+            bufferR = bufferR * 0
+
+        if ((stepCounter > 0) and (stepCounter % rootEvery == 0)):
+            LEigenvalue, LEigenvector = np.linalg.eig(preconL)
+            preconLInvPowerRoot = LEigenvector @ np.diag(LEigenvalue**(-0.25)) @ LEigenvector.T
+
+            REigenvalue, REigenvector = np.linalg.eig(preconR)
+            preconRInvPowerRoot = REigenvector @ np.diag(REigenvalue**(-0.25)) @ REigenvector.T
+
+        X = X - lr * preconLInvPowerRoot @ momentum @ preconRInvPowerRoot
+  
+  # Diagonal Shampoo:
+  # Memory-efficient approximation for large parameter matrices
+    else:
+        n = dX.shape[0]
+        m = dX.shape[1]
+
+        bufferL = bufferL + (dX**2).sum(axis=1, keepdims=True)    
+        bufferR = bufferR + (dX**2).sum(axis=0, keepdims=True)
+
+        if ((stepCounter > 0) and (stepCounter % preconEvery == 0)):
+            preconL = preconL +  bufferL     
+            preconR = preconR + bufferR
+            bufferL = bufferL * 0
+            bufferR = bufferR * 0
+        
+        if ((stepCounter > 0) and (stepCounter % rootEvery == 0)):
+            preconLInvPowerRoot = preconL**(-0.25)        
+            preconRInvPowerRoot = preconR**(-0.25)
+
+        preconLMatrix = preconLInvPowerRoot @ np.ones(shape=[1, m])
+        preconRMatrix = np.ones(shape=(n, 1)) @ preconRInvPowerRoot
+
+        scaledGrad = momentum * preconLMatrix
+        scaledGrad = scaledGrad * preconRMatrix
+
+        X = X - lr * scaledGrad
+
+    return(X, preconL, preconR, momentum, stepCounter, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot)
+
+# init shampoo
+
+def init_shampoo_heuristic(X, epsilon, useDiagThreshold):
+    if((X.shape[0] > useDiagThreshold) or (X.shape[1] > useDiagThreshold)):
+        preconL = np.full(shape=(X.shape[0], 1), fill_value=epsilon, dtype=np.float64)
+        preconR = np.full(shape=(1, X.shape[1]), fill_value=epsilon, dtype=np.float64)
+        preconLInvPowerRoot = preconL**(-0.25)
+        preconRInvPowerRoot = preconR**(-0.25)
+        useDiag = True
+    else:
+        preconL = np.eye(X.shape[0], dtype=np.float64) * epsilon
+        preconR = np.eye(X.shape[1], dtype=np.float64) * epsilon
+        preconLInvPowerRoot = np.eye(X.shape[0], dtype=np.float64) * epsilon**(-0.25)
+        preconRInvPowerRoot = np.eye(X.shape[1], dtype=np.float64) * epsilon**(-0.25)
+
+        useDiag = False
+
+    momentum = X * 0
+    bufferR = preconR * 0
+    bufferL = preconL * 0
+    stepCounter = 0
+    return(preconL, preconR, stepCounter, bufferL, bufferR, momentum, preconLInvPowerRoot, preconRInvPowerRoot, useDiag)
+
+
+
+# define weight matrix
+X_main = np.array([
+    [ 0.12, -0.45,  0.33,  0.08, -0.19],
+    [-0.27,  0.41, -0.05,  0.22,  0.14],
+    [ 0.09, -0.31,  0.26, -0.48,  0.37],
+    [ 0.44,  0.06, -0.29,  0.15, -0.11],
+    [-0.38,  0.24,  0.17, -0.07,  0.52],
+], dtype=np.float64)
+
+# define gradient
+dX_main = np.array([
+    [ 0.015, -0.022,  0.008,  0.031, -0.012],
+    [-0.009,  0.027, -0.014,  0.005,  0.019],
+    [ 0.021, -0.006,  0.011, -0.025,  0.004],
+    [-0.018,  0.013, -0.029,  0.007, -0.016],
+    [ 0.010, -0.017,  0.024, -0.003,  0.028],
+], dtype=np.float64)
+
+with SystemDSContext() as sds:
+    n = 5
+    m = 5
+    epsilon = 1e-4
+    lr = 0.005
+    diagThreshold = 10
+    rootEvery=10
+    preconEvery=10
+    
+    shampooUtils = sds.source("src/test/scripts/applications/nn/component/shampoo_test_utils.dml", "shampooUtils")
+
+    for shampoo_type in ["shampoo", "shampoo_momentum", "shampoo_heuristic"]:
+        for diagThreshold in (1, 10):
+            X = X_main.copy()
+            dX = dX_main.copy()
+            
+            if shampoo_type=="shampoo":
+                preconL_py, preconR_py, useDiag_py = init_shampoo(X, epsilon, diagThreshold)
+                X_py, preconL_py, preconR_py = update_shampoo(X, dX, lr, preconL_py, preconR_py, useDiag_py)
+            elif shampoo_type=="shampoo_momentum":
+                preconL_py, preconR_py, momentum_py, useDiag_py = init_shampoo_momentum(X, epsilon, diagThreshold)
+                X_py, preconL_py, preconR_py, momentum_py = update_shampoo_momentum(X, dX, lr, preconL_py, preconR_py, momentum_py, useDiag_py)
+            elif shampoo_type=="shampoo_heuristic":
+                preconL, preconR, stepCounter, bufferL, bufferR, momentum, preconLInvPowerRoot, preconRInvPowerRoot, useDiag = init_shampoo_heuristic(X, epsilon, diagThreshold)
+                X_py, preconL, preconR, momentum, stepCounter, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot = update_shampoo_heuristic(X, dX, lr, preconL, preconR, momentum, stepCounter, rootEvery, preconEvery, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot, useDiag)
+            
+            X_updated = shampooUtils.test_update(sds.from_numpy(X), sds.from_numpy(dX), sds.scalar(shampoo_type), epsilon, lr, diagThreshold, rootEvery, preconEvery).compute()
+            X_updated = np.asarray(X_updated, dtype=np.float64)
+
+            identical = np.allclose(X_py, X_updated, rtol=1e-7, atol=1e-9)
+
+            diagonal = "diagonal" if diagThreshold==1 else "non-diagonal"
+
+            print(f"{shampoo_type} - {diagonal}: {'Test Passed' if identical else 'Test Failed'}")
+
+
+
diff --git a/src/test/scripts/applications/nn/component/shampoo_test_utils.dml b/src/test/scripts/applications/nn/component/shampoo_test_utils.dml
new file mode 100644
index 00000000000..ef1c62f7c0e
--- /dev/null
+++ b/src/test/scripts/applications/nn/component/shampoo_test_utils.dml
@@ -0,0 +1,63 @@
+#-------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+#-------------------------------------------------------------
+
+source("scripts/nn/optim/shampoo.dml") as shampoo
+
+test_update = function(matrix[double] X, matrix[double] dX, string type, double epsilon, double lr, int diagThreshold, int rootEvery, int preconEvery)
+  /*
+  * Applies a single optimization update step to X using a selected Shampoo variant.
+  *
+  * This helper initializes the required optimizer state for the given `type`
+  * (preconditioners, momentum, buffers, cached inverse roots, etc.) and then
+  * performs exactly one update with gradient `dX`.
+  *
+  * Note:
+  *  - This function re-initializes the optimizer state on every call, so it is
+  *    intended for isolated single-step tests/benchmarks, not for training loops
+  *    where state must persist across steps.
+  *
+  * Inputs:
+  *  - X: Current parameter matrix
+  *  - dX: Gradient matrix (same shape as X)
+  *  - type: Optimizer variant ("shampoo", "shampoo_momentum", "shampoo_heuristic")
+  *  - epsilon: Numerical stability constant
+  *  - lr: Learning rate
+  *  - diagThreshold: Threshold controlling diagonal vs full preconditioning
+  *  - rootEvery: (heuristic only) Recompute inverse-root frequency
+  *  - preconEvery: (heuristic only) Preconditioner update frequency
+  *
+  * Output:
+  *  - XUpdated: Updated parameter matrix after one optimizer step
+  */
+    return(matrix[double] XUpdated){
+      if (type=="shampoo"){
+        [preconL, preconR, useDiag] = shampoo::init(X, epsilon, diagThreshold)
+        [XUpdated, preconL, preconR] = shampoo::update(X, dX, lr, preconL, preconR, useDiag)
+      }
+      else if (type=="shampoo_momentum"){
+        [preconL, preconR, momentum, useDiag] = shampoo::init_momentum(X, epsilon, diagThreshold)
+        [XUpdated, preconL, preconR, momentum] = shampoo::update_momentum(X, dX, lr, preconL, preconR, momentum, useDiag)
+      }
+      else if (type=="shampoo_heuristic"){
+        [preconL, preconR, stepCounter, bufferL, bufferR, momentum, preconLInvPowerRoot, preconRInvPowerRoot, useDiag] = shampoo::init_heuristic(X, epsilon, diagThreshold)
+        [XUpdated, preconL, preconR, momentum, stepCounter, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot] = shampoo::update_heuristic(X, dX, lr, preconL, preconR, momentum, stepCounter, rootEvery, preconEvery, bufferL, bufferR, preconLInvPowerRoot, preconRInvPowerRoot, useDiag)
+      }
+    }