diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/README.md b/VLSI24/submitted_notebooks/SJSystolicArray/README.md
new file mode 100644
index 00000000..e85bd4e0
--- /dev/null
+++ b/VLSI24/submitted_notebooks/SJSystolicArray/README.md
@@ -0,0 +1,2 @@
+# SiliconJackets Systolic Array
+This notebook goes through the process of design specification, simulation, and implementation of a Systolic Array with open-source tools and PDKs. The parallel computation and data reuse ability of a systolic array is crucial for the acceleration of neural networks, and this notebook with the reusable design aims to contribute to the hardware open-source community to enable more efficient ML applications. This project will explain the principles behind how a systolic array operates 2D convolution, demonstrate the performance of our implementation with image results, and show the final GDS generated with open-source flow. Additionally, to further demonstrate the feasibility of the open-source flow and our design, we are also submitting this systolic array design to the open-source silicon initiative, [Tiny Tapeout](https://tinytapeout.com/). This submission is completed by members of SiliconJackets. We are a student run organization at Georgia Tech that introduces students to semiconductor design, verification, and implementation through a large collaborative project. We are hoping to use this notebook as an example for future members of the club.
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/SystolicArray.ipynb b/VLSI24/submitted_notebooks/SJSystolicArray/SystolicArray.ipynb
new file mode 100644
index 00000000..c394e27d
--- /dev/null
+++ b/VLSI24/submitted_notebooks/SJSystolicArray/SystolicArray.ipynb
@@ -0,0 +1,1598 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/SystolicArray.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "VV2vOq0Oq_CF"
+      },
+      "source": [
+        "# Row Stationary Systolic Array With Openlane\n",
+        "\n",
+        "```\n",
+        "Copyright 2024 SiliconJackets @ Georgia Institute of Technology\n",
+        "SPDX-License-Identifier: GPL-3.0-or-later\n",
+        "```\n",
+        "\n",
+        "Running a 3x3 systolic array design inspired by [EYERISS](https://courses.cs.washington.edu/courses/cse550/21au/papers/CSE550.Eyeriss.pdf) design thru the [OpenLane](https://github.com/The-OpenROAD-Project/OpenLane/) GDS to RTL flow targeting the [open source SKY130 PDK](https://github.com/google/skywater-pdk/)."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pzPuBWmSrjK_"
+      },
+      "source": [
+        "|Name|Affiliation| Email |IEEE Member|SSCS Member|\n",
+        "|:--:|:----------:|:----------:|:----------:|:----------:|\n",
+        "|Zachary Ellis|Georgia Institute of Technology|zellis7@gatech.edu|Yes|Yes|\n",
+        "|Nealson Li|Georgia Institute of Technology|nealson@gatech.edu|Yes|Yes|\n",
+        "|Addison Elliott|Georgia Institute of Technology|addisonelliott@gatech.edu|No|No|\n",
+        "|Zeyan Wu|Georgia Institute of Technology|zwu477@gatech.edu|No|No|\n",
+        "|Jingsong Guo|Georgia Institute of Technology|guojingsong@gatech.edu|No|No|"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wCAFcKzsBMgE"
+      },
+      "source": [
+        "This notebook goes through the process of design specification, simulation, and implementation of a Systolic Array with open-source tools and PDKs. The parallel computation and data reuse ability of a systolic array is crucial for the acceleration of neural networks, and this notebook with the reusable design aims to contribute to the hardware open-source community to enable more efficient ML applications. This project will explain the principles behind how a systolic array operates 2D convolution, demonstrate the performance of our implementation with image results, and show the final GDS generated with open-source flow. Additionally, to further demonstrate the feasibility of the open-source flow and our design, we are also submitting this systolic array design to the open-source silicon initiative, [Tiny Tapeout](https://tinytapeout.com/). This submission is completed by members of SiliconJackets. We are a student run organization at Georgia Tech that introduces students to semiconductor design, verification, and implementation through a large collaborative project. We are hoping to use this notebook as an example for future members of the club.\n",
+        "\n",
+        "\n",
+        "\n",
+        "<!-- In this notebook we will be going through the process of design specification, simulation, and implementation for a resource constrained design intended to submitted to another open source silicon initiative [Tiny Tapeout](https://tinytapeout.com/). Tiny tapeout allows individuals to purchase tiny 160um x 100um blocks on a silicon die for an acceptable price in order to gain exposure to the semiconductor deisng process. Our plan is to create a hardware accelerator for Convolutional Neural Networks \\(CNNs\\), losely based on the design from [EYERISS](https://courses.cs.washington.edu/courses/cse550/21au/papers/CSE550.Eyeriss.pdf) for the purpose of recognizing hardwritten numbers. This project will demonstrate the principles behind how a systolic array operates for doing 2D convolution operators, demonstrate the performance of our implementation, and show how the final design can fit within *a few* tiny tapeout blocks. -->\n",
+        "\n",
+        "\n",
+        "<!-- From the github page\n",
+        "\n",
+        "1. Promote reproducible chip design using open-source tools and notebook-driven design flows and\n",
+        "2. Enable up-and-coming talents as well as seasoned open-source enthusiasts to travel to IEEE SSCS conferences and interact with the leading-edge chip design community.\n",
+        "\n",
+        "Applicants must submit an open-source Jupyter notebook detailing an innovative circuit design using open-source tools. The objective is to disseminate the main ideas and design choices using open-source tools and PDKs in a reproducible manner. Generating a final layout of your circuit is encouraged but not required. -->\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "4RZvXIjpdd7d"
+      },
+      "source": [
+        "## Introduction\n",
+        "---\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "cmDD-DzHEB0H"
+      },
+      "source": [
+        "In this noteboook, we will first explain what a systolic array is and its application by referencing the row stationary data flow introduced in [EYERISS](https://courses.cs.washington.edu/courses/cse550/21au/papers/CSE550.Eyeriss.pdf), which our design is losely based on. Then, the hardware specification and design of the high level architecture and processing unit are explained. We will then demonstrate the performance by simulating the hardware design to perform convolution for an edge detection task, and verify it with the software golden referrence. Lastly, the systolic array is pushed through [OpenLane](https://github.com/The-OpenROAD-Project/OpenLane/) RTL to GDS flow with the open-source [SKY130 PDK](https://github.com/google/skywater-pdk/)."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "w-Nig77dBMgF"
+      },
+      "source": [
+        "## Systolic Array\n",
+        "---"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "c_0UEEX4fn75"
+      },
+      "source": [
+        "### What is a Systolic Array\n",
+        "\n",
+        "A systolic array is a 2D array of individual processing elements, which can each independently compute. Systolic arrays allow massive parallel computation which is largely useful for machine learning applications which can require a large number of MACs (Multiply and Accumulates) that are not dependent on one another. This array construction not only allows the massive parallel computation abilities, but also facilitates data reuse which reduces the memory bottleneck. By scheduling operations correctly for something like matrix multiplication of 2D+ convolution, PEs that are next to each other may use similar data in their operations. Because of the PE arrangement, this data can be passed between PEs directly, which means it only has to be fetched once from memory. In this notebook we present a 3x3 systolic array which uses row stationary dataflow and show how it passes data between PEs for maximum data reuse and minimum required bandwidth."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Convolutions and Systolic Arrays\n",
+        "In the realm of signal processing and machine learning, convolution plays a fundamental role in various applications such as image processing, video processing, and digital filtering. A two-dimensional convolution (Conv2D) is a mathematical operation involving sliding a filter matrix over a larger input matrix to produce an output, which is a fundamental operation in many algorithms, including those employed in computer vision and machine learning applications.\n",
+        "The convolution operation naturally allows for significant data reuse, as any value from the input, filter, or output matrices will be used many times in different multiplication/addition calculations (MACs). The key to exploiting this opportunity for efficient convolutions is to use highly parallel hardware to reuse data loaded from memory as much as possible before it's returned to memory.\n",
+        "In a systolic array, data is loaded from memory and flows through a grid of identical processing elements (PEs), being reused differently in each PE over different clock cycles. The flow of data through the system can be compared to the flow of blood being pumped through the circulatory system.\n",
+        "Systolic arrays are very useful for matrix multiplication (GEMM), and before the row-stationary (RS) dataflow was used, convolution operations were converted into large GEMM operations before they could flow through the array of PEs. However, with the modified RS dataflow which we implemented in our design, the systolic-like array directly computes the Conv2D of the input and filter matrix efficiently."
+      ],
+      "metadata": {
+        "id": "fwC2HFbnlfwD"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "XwpY9TT-fs0C"
+      },
+      "source": [
+        "#### Row Stationary Dataflow"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pgWw7tPeBMgF"
+      },
+      "source": [
+        "In a row stationary dataflow, the individual processing elements in a systolic array each have small amounts of scratchpad memory which is devoted to keep row value data in place while it is operated on. In this mode, each processing element computes a single output from a 1D convolution operation and then those partial sums are added down the columns for the final outputs. During the initial loading of the filter weights and row data, the full scratchpads need to be populated before any computation can occur, but as the convolution operation moves across the rows, only one new byte of data needs to be read per PE making this form of 2D convolution operation very memory efficient.\n",
+        "\n",
+        "<div>\n",
+        "<img src=\"https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/systolic_array_flow.gif?raw=1\" width=\"1000\"/>\n",
+        "</div>\n",
+        "\n",
+        "<!-- ![Flow](https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/systolic_array_flow.gif?raw=true){: width=250} -->"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "rk799ZBaBMgF"
+      },
+      "source": [
+        "#### Applications"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "XJCgjjfJBMgH"
+      },
+      "source": [
+        "The main application for row stationary systolic arrays is 2D convolution. A convolution operation applies a filter kernel to a 2D input (for example an image) which then transforms the image to pull out specific details. A convolution may be able to pick out the edges of objects as shown in this notebook, or a chain of convolutions such as in a convolutional neural network may be able to filter out more complex shapes for object recognition or something like a dog. Using a systolic array to do 2D convolution is very quick and efficient which is why this hardware is the basis for many machine learning accelerators."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nE8mvJTtf8Vj"
+      },
+      "source": [
+        "### How is the hardware designed?\n",
+        "\n",
+        "In order to show off the high memory efficiency of row stationary dataflow, the external memory connections for the top level of this design are very limited. With 2 read ports and 1 write port, this design is only able to read in 16 bits of data each cycle and write 8 bits. However, this data is reused across PEs allowing up to 9 MACs a cycle with different data combinations.\n",
+        "\n",
+        "<div>\n",
+        "<img src=\"https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/Top.png?raw=1\" width=\"1000\"/>\n",
+        "</div>\n",
+        "\n",
+        "<!-- ![Flow](https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/Top.png?raw=true){: width=250} -->"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "IiS5mhFrBMgH"
+      },
+      "source": [
+        "#### Top Level Design"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xjEMHpZ2BMgH"
+      },
+      "source": [
+        "The top-level controller is responsible for controlling the timing of data read and operation start for all the PEs. Taking in the size of the input from the memory interface on the first cycle, the top-level controller then schedules the control signals for the individual PEs to read the data on the memory bus when it is their turn. When a PE has the data it needs, and it is it's turn in the sequence to start it's 1D convolution, the top-level controller asserts the start signal for that PE. Because of the staggering of start times, the state machines inside the PEs will run such that the data is automatically summed up the column of the PE and only one result is available for writing at a time.\n",
+        "\n",
+        "<div>\n",
+        "<img src=\"https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/Ctrl.png?raw=1\" width=\"1000\"/>\n",
+        "</div>\n",
+        "\n",
+        "<!-- ![Flow](https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/Ctrl.png?raw=true){: width=250} -->"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Wxlw9LhCBMgH"
+      },
+      "source": [
+        "#### PE Design"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fMnogy0ZBMgH"
+      },
+      "source": [
+        "In order to reduce complexity and area the control structure inside each PE is kept very simple. When the PE sees a control signal to read in a new input or filter value from the top-level controller, it will read in a new value into the scratchpad and shift existing values over evicting the oldest value (with a depth of 3). Once the PE sees a start signal it will spend 3 cycles doing MACs with the scratchpad values and then sum with the input psum. With the PE start signals staggered across the array, the psum_o for one PE in a column becomes psum_i for the PE above it with the top PE presenting a final value at the output. These PEs always rely on the correct data being present at the correct time which is possible with the scheduling of the memory transactions and top-level controller.\n",
+        "\n",
+        "<div>\n",
+        "<img src=\"https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/PE.png?raw=1\" width=\"1000\"/>\n",
+        "</div>\n",
+        "\n",
+        "<!-- ![Flow](https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/PE.png?raw=true){width=250} -->"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "PXz0NAIzgDob"
+      },
+      "source": [
+        "## Simulation\n",
+        "---"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "qxSqLtXoBMgH"
+      },
+      "source": [
+        "### Edge Detection with 2D Convolution accelarated by Systolic Array\n",
+        "<!-- Explain convolving the input image with sobel filter emhances the edge of the objects, and the convolution can be accelerated by the Systolic array. -->\n",
+        "\n",
+        "To demonstrate our systolic array's ability to accelerate convolution operation, we are performing Canny edge detection which requires convolving an image. The edges of an image are enhanced after it is convolved with Sobel filters in x and y direction separately. The filters are 3x3 kernels show as below:\n",
+        "\n",
+        "$$\\text{Sobel Filter x} =\n",
+        "\\begin{bmatrix}\n",
+        "-0.5 & 0 & 0.5 \\\\\n",
+        "-1.0 & 0 & 1.0 \\\\\n",
+        "-0.5 & 0 & 0.5\n",
+        "\\end{bmatrix}$$\n",
+        "\n",
+        "$$\\text{Sobel Filter y} =\n",
+        "\\begin{bmatrix}\n",
+        "-0.5 & -1.0 & -0.5 \\\\\n",
+        "0 & 0 & 0 \\\\\n",
+        "0.5 & 1.0 & 0.5\n",
+        "\\end{bmatrix}$$\n",
+        "\n",
+        "The results are the first derivative in the x and y directions, $grad_x$ and $grad_y$, we can then iterate through all the pixels and calculate the intensity gradient of the image, which represents the edges, with:\n",
+        "\n",
+        "$$\\text{Grad Intensity} = \\sqrt{grad_x ^ 2 + grad_y ^ 2}$$\n",
+        "\n",
+        "We have a python implementation of the Canny edge detection algorithm as our golden reference to verify or systolic array design. Dedicated data sequence generator is developed with the hardware architecture data flow to process the image and kernels and generate input sequence to the systolic array. The example image that undergoes the convolution operation in both the hardware simulation and the software is:\n",
+        "\n",
+        "<div>\n",
+        "<img src=\"https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/src/python/rubiks_cube.jpg?raw=1\"/>\n",
+        "</div>\n",
+        "\n",
+        "The demonstration has following steps:\n",
+        "1. Install the software dependencies\n",
+        "2. Download the python and verilog files of our design\n",
+        "3. Run convolution in both software and hardware:\n",
+        "\n",
+        "    a. Grayscale and resize the input image to 256 by 256\n",
+        "    \n",
+        "    b. In software, performe convolution and generate the golden image\n",
+        "    \n",
+        "    c. In hardware, performe convolution\n",
+        "\n",
+        "    d. In software, process the hardware result and generate the output image\n",
+        "\n",
+        "4. Compare the golden image and the output image\n",
+        "\n",
+        "We would first demonstrate with the rubik's cube image, after this example you can upload any image to try it out, and see how well the systolic array accelerated edge detection is performing.\n",
+        "\n",
+        "\n",
+        "<!--\n",
+        "Explain image size, show original image.\n",
+        "\n",
+        "Explain the following experiment steps -->"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [],
+      "metadata": {
+        "id": "DfQc3lWL4722"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_nx0Xss6Nu3u",
+        "outputId": "8374f171-c07d-4e18-b3e7-6e3ecc8ceaf7"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Reading package lists... Done\n",
+            "Building dependency tree... Done\n",
+            "Reading state information... Done\n",
+            "verilator is already the newest version (4.038-1).\n",
+            "0 upgraded, 0 newly installed, 0 to remove and 45 not upgraded.\n",
+            "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.2.1+cu121)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.13.4)\n",
+            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch) (4.11.0)\n",
+            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch) (1.12)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.3)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.3)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2023.6.0)\n",
+            "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.105)\n",
+            "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.105)\n",
+            "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.105)\n",
+            "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /usr/local/lib/python3.10/dist-packages (from torch) (8.9.2.26)\n",
+            "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.3.1)\n",
+            "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /usr/local/lib/python3.10/dist-packages (from torch) (11.0.2.54)\n",
+            "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /usr/local/lib/python3.10/dist-packages (from torch) (10.3.2.106)\n",
+            "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /usr/local/lib/python3.10/dist-packages (from torch) (11.4.5.107)\n",
+            "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.0.106)\n",
+            "Requirement already satisfied: nvidia-nccl-cu12==2.19.3 in /usr/local/lib/python3.10/dist-packages (from torch) (2.19.3)\n",
+            "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.105)\n",
+            "Requirement already satisfied: triton==2.2.0 in /usr/local/lib/python3.10/dist-packages (from torch) (2.2.0)\n",
+            "Requirement already satisfied: nvidia-nvjitlink-cu12 in /usr/local/lib/python3.10/dist-packages (from nvidia-cusolver-cu12==11.4.5.107->torch) (12.4.127)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (2.1.5)\n",
+            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch) (1.3.0)\n",
+            "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (0.17.1+cu121)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision) (1.25.2)\n",
+            "Requirement already satisfied: torch==2.2.1 in /usr/local/lib/python3.10/dist-packages (from torchvision) (2.2.1+cu121)\n",
+            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision) (9.4.0)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (3.13.4)\n",
+            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (4.11.0)\n",
+            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (1.12)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (3.3)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (3.1.3)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (2023.6.0)\n",
+            "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (12.1.105)\n",
+            "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (12.1.105)\n",
+            "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (12.1.105)\n",
+            "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (8.9.2.26)\n",
+            "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (12.1.3.1)\n",
+            "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (11.0.2.54)\n",
+            "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (10.3.2.106)\n",
+            "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (11.4.5.107)\n",
+            "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (12.1.0.106)\n",
+            "Requirement already satisfied: nvidia-nccl-cu12==2.19.3 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (2.19.3)\n",
+            "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (12.1.105)\n",
+            "Requirement already satisfied: triton==2.2.0 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.1->torchvision) (2.2.0)\n",
+            "Requirement already satisfied: nvidia-nvjitlink-cu12 in /usr/local/lib/python3.10/dist-packages (from nvidia-cusolver-cu12==11.4.5.107->torch==2.2.1->torchvision) (12.4.127)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch==2.2.1->torchvision) (2.1.5)\n",
+            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch==2.2.1->torchvision) (1.3.0)\n",
+            "Requirement already satisfied: opencv-python in /usr/local/lib/python3.10/dist-packages (4.8.0.76)\n",
+            "Requirement already satisfied: numpy>=1.21.2 in /usr/local/lib/python3.10/dist-packages (from opencv-python) (1.25.2)\n",
+            "Requirement already satisfied: fxpmath in /usr/local/lib/python3.10/dist-packages (0.4.9)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from fxpmath) (1.25.2)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.25.2)\n"
+          ]
+        }
+      ],
+      "source": [
+        "#@title Install Dependencies {display-mode: \"form\"}\n",
+        "#@markdown Click the ▷ button to setup the simulation environment.\n",
+        "\n",
+        "#@markdown Main components we will install\n",
+        "\n",
+        "#@markdown *   verilator : a free and open-source software tool which converts Verilog (a hardware description language) to a cycle-accurate behavioral model in C++ or SystemC.\n",
+        "#@markdown *   pytorch : Used to format input data for the systolic array from the image files and do edge detection in software for the golden reference\n",
+        "#@markdown *   opencv : Used for input image manipulation\n",
+        "#@markdown *   fxpmath : This module helps emulate the floating point math behavior of our systolic array\n",
+        "\n",
+        "%load_ext autoreload\n",
+        "%autoreload 2\n",
+        "!apt-get install verilator\n",
+        "!pip install torch\n",
+        "!pip install torchvision\n",
+        "!pip install opencv-python\n",
+        "!pip install fxpmath\n",
+        "!pip install numpy"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "ekdNyNjnBMgI",
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "\n",
+        "#@title Download Systolic Array Files\n",
+        "\n",
+        "#@markdown Click the ▷ button to download the rtl files.\n",
+        "#@markdown The files will be downloaded to the SytolicArray directory\n",
+        "#@markdown the file structure is described below:\n",
+        "\n",
+        "#@markdown *   SystolicArray/src\n",
+        "#@markdown    *  python/\n",
+        "#@markdown       *   `canny.py` : python implementation of the Canny Edge Detection algorithm\n",
+        "#@markdown       *   `full_flow.py` : performes the edge detection on a given image with either software or hardware\n",
+        "#@markdown       *   `rubiks_cube.jpg` : the default example image\n",
+        "#@markdown       *   `seq_generator.py` : generates the Systolic Array input sequence from the image and kernel\n",
+        "#@markdown    *   `PE.sv` : This is the implementation of an individual processing element that is instantiated in a 3x3 array\n",
+        "#@markdown    *   `tb_top.cpp` : This is the verilator testbench used for running image data through the systolic array\n",
+        "#@markdown    *   `top.sv` : This is the top level file where all modules are instantiated and connected to each other / IO ports\n",
+        "#@markdown    *   `topLevelControl.sv` : This module generates control signals for all of the PEs based on the size of the input. It coordinates data loading as well as starts the 1D convolution operations in each PE\n",
+        "\n",
+        "%cd /content/\n",
+        "!rm -rf SystolicArray\n",
+        "!git clone https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io.git SystolicArray\n",
+        "!mv SystolicArray/VLSI24/submitted_notebooks/SJSystolicArray/src SystolicArray/\n",
+        "!mv SystolicArray/VLSI24/submitted_notebooks/SJSystolicArray/img SystolicArray/\n",
+        "!rm -rf SystolicArray/ISSCC23/\n",
+        "!rm -rf SystolicArray/ISSCC24/\n",
+        "!rm -rf SystolicArray/VLSI23/\n",
+        "!rm -rf SystolicArray/VLSI24/\n",
+        "!rm SystolicArray/*.md\n",
+        "!rm SystolicArray/LICENSE"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "uE5D3C5IxlWy"
+      },
+      "source": [
+        "### Compile Verilator Testbench"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QXfKFOdVTMJF",
+        "outputId": "59970d1c-b267-4f29-86cc-3c179e407884"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "/content\n",
+            "make: Entering directory '/content/obj_dir'\n",
+            "g++  -I.  -MMD -I/usr/share/verilator/include -I/usr/share/verilator/include/vltstd -DVM_COVERAGE=0 -DVM_SC=0 -DVM_TRACE=1 -faligned-new -fcf-protection=none -Wno-bool-operation -Wno-sign-compare -Wno-uninitialized -Wno-unused-but-set-variable -Wno-unused-parameter -Wno-unused-variable -Wno-shadow      -Os -c -o tb_top.o ../SystolicArray/src/tb_top.cpp\n",
+            "g++  -I.  -MMD -I/usr/share/verilator/include -I/usr/share/verilator/include/vltstd -DVM_COVERAGE=0 -DVM_SC=0 -DVM_TRACE=1 -faligned-new -fcf-protection=none -Wno-bool-operation -Wno-sign-compare -Wno-uninitialized -Wno-unused-but-set-variable -Wno-unused-parameter -Wno-unused-variable -Wno-shadow      -Os -c -o verilated.o /usr/share/verilator/include/verilated.cpp\n",
+            "g++  -I.  -MMD -I/usr/share/verilator/include -I/usr/share/verilator/include/vltstd -DVM_COVERAGE=0 -DVM_SC=0 -DVM_TRACE=1 -faligned-new -fcf-protection=none -Wno-bool-operation -Wno-sign-compare -Wno-uninitialized -Wno-unused-but-set-variable -Wno-unused-parameter -Wno-unused-variable -Wno-shadow      -Os -c -o verilated_vcd_c.o /usr/share/verilator/include/verilated_vcd_c.cpp\n",
+            "/usr/bin/perl /usr/share/verilator/bin/verilator_includer -DVL_INCLUDE_OPT=include Vtop.cpp Vtop__Trace.cpp Vtop__Slow.cpp Vtop__Syms.cpp Vtop__Trace__Slow.cpp > Vtop__ALL.cpp\n",
+            "g++  -I.  -MMD -I/usr/share/verilator/include -I/usr/share/verilator/include/vltstd -DVM_COVERAGE=0 -DVM_SC=0 -DVM_TRACE=1 -faligned-new -fcf-protection=none -Wno-bool-operation -Wno-sign-compare -Wno-uninitialized -Wno-unused-but-set-variable -Wno-unused-parameter -Wno-unused-variable -Wno-shadow      -Os -c -o Vtop__ALL.o Vtop__ALL.cpp\n",
+            "ar -cr Vtop__ALL.a Vtop__ALL.o\n",
+            "ranlib Vtop__ALL.a\n",
+            "g++    tb_top.o verilated.o verilated_vcd_c.o Vtop__ALL.a      -o Vtop\n",
+            "make: Leaving directory '/content/obj_dir'\n"
+          ]
+        }
+      ],
+      "source": [
+        "%cd /content/\n",
+        "!rm -rf obj_dir\n",
+        "!verilator --trace --cc SystolicArray/src/top.sv SystolicArray/src/topLevelControl.sv SystolicArray/src/PE.sv --exe SystolicArray/src/tb_top.cpp\n",
+        "!make -C obj_dir -f Vtop.mk Vtop"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "z0vRPk19x0z2"
+      },
+      "source": [
+        "### Run 2D Convolution in both Software and Hardware\n",
+        "Using full_flow.py, we run an image through a software only version of the edge detection algorithm to get a golden reference. Then we generate `seq_x.txt`, and `seq_y.txt` which are used as input data for the verilator testbench. The results from verilator are collected by the script and written to the image file `edge_rubiks_cube_sa.jpg` all files can be found in the `SystolicArray/src/python/` directory."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "c4xh0hf5m552",
+        "outputId": "7e05221b-0f99-4ff4-e604-e0df64151a99"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "/content/SystolicArray/src/python\n"
+          ]
+        }
+      ],
+      "source": [
+        "%cd /content/SystolicArray/src/python/\n",
+        "!python3 full_flow.py rubikscube"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "cellView": "form",
+        "id": "4X678sSQxyc2",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 305
+        },
+        "outputId": "b950f39d-2601-4522-85b3-18c6a28b2fdd"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Text(0.5, 1.0, 'Systolic Array Edge Detection')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 5
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x700 with 3 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "#@title Compare Results\n",
+        "\n",
+        "#@markdown Because the hardware is limited to 8 bit integer math, the output is not as bright as the software version, but it is still able to achieve a similar looking result\n",
+        "\n",
+        "\n",
+        "# code for displaying multiple images in one figure\n",
+        "\n",
+        "#import libraries\n",
+        "import cv2\n",
+        "from matplotlib import pyplot as plt\n",
+        "\n",
+        "# create figure\n",
+        "fig = plt.figure(figsize=(10, 7))\n",
+        "\n",
+        "# setting values to rows and column variables\n",
+        "rows = 1\n",
+        "columns = 3\n",
+        "\n",
+        "# reading images\n",
+        "Image1 = cv2.imread('/content/SystolicArray/src/python/rubiks_cube.jpg')\n",
+        "Image2 = cv2.imread('/content/SystolicArray/src/python/edge_rubiks_cube.jpg')\n",
+        "Image3 = cv2.imread('/content/SystolicArray/src/python/edge_rubiks_cube_sa.jpg')\n",
+        "\n",
+        "#Adds a subplot at the 1st position\n",
+        "fig.add_subplot(rows, columns, 1)\n",
+        "\n",
+        "# showing image\n",
+        "plt.imshow(Image1)\n",
+        "plt.axis('off')\n",
+        "plt.title(\"Original\")\n",
+        "\n",
+        "# Adds a subplot at the 2nd position\n",
+        "fig.add_subplot(rows, columns, 2)\n",
+        "\n",
+        "# showing image\n",
+        "plt.imshow(Image2)\n",
+        "plt.axis('off')\n",
+        "plt.title(\"Software Edge Detection\")\n",
+        "\n",
+        "# Adds a subplot at the 3rd position\n",
+        "fig.add_subplot(rows, columns, 3)\n",
+        "\n",
+        "# showing image\n",
+        "plt.imshow(Image3)\n",
+        "plt.axis('off')\n",
+        "plt.title(\"Systolic Array Edge Detection\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "t4auaKP0BMgJ"
+      },
+      "source": [
+        "### Try it yourself"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "lwsAIO0WBMgJ",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 67,
+          "referenced_widgets": [
+            "0e66c80f52844968a03503ce83a094d3",
+            "466bae39c60e4d9e959805ad72c5b0ca",
+            "69a7b45aa0c8418dbf29b03f181842f8",
+            "a190641ce2f2487b9acfc91e931f7ece",
+            "dbeebae2d6e54cffb3f2bb1ba751071d",
+            "330f9dbba2714e35bcc1335fd74f8dcd"
+          ]
+        },
+        "cellView": "form",
+        "outputId": "f15a0271-6179-4b49-a1c6-cfa5f094a2b5"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "FileUpload(value={}, accept='.jpg', description='Upload')"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "a190641ce2f2487b9acfc91e931f7ece"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Image successfully uploaded!\n"
+          ]
+        }
+      ],
+      "source": [
+        "#@markdown Click the ▷ button to upload your own image for edge detection\n",
+        "\n",
+        "from google.colab import files\n",
+        "import ipywidgets as widgets\n",
+        "from IPython.display import display, clear_output\n",
+        "\n",
+        "UPLOADED = False\n",
+        "\n",
+        "def upload_image(_):\n",
+        "    clear_output()\n",
+        "    upload_widget = widgets.FileUpload(accept='.jpg', multiple=False)\n",
+        "    display(upload_widget)\n",
+        "    upload_widget.observe(save_image, names='value')\n",
+        "\n",
+        "def save_image(change):\n",
+        "    global UPLOADED\n",
+        "    if change.new:\n",
+        "        uploaded_filename = next(iter(change.new))\n",
+        "        content = change.new[uploaded_filename]['content']\n",
+        "        with open('/content/SystolicArray/src/python/uploadedimage.jpg', 'wb') as f:\n",
+        "            f.write(content)\n",
+        "            UPLOADED = True\n",
+        "        print('Image successfully uploaded!')\n",
+        "    else:\n",
+        "        print('Please select a file.')\n",
+        "\n",
+        "upload_button = widgets.Button(description=\"Upload Image\")\n",
+        "upload_button.on_click(upload_image)\n",
+        "display(upload_button)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2XB-luVMBMgJ",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 305
+        },
+        "cellView": "form",
+        "outputId": "e14c7766-a732-4ea5-ba07-8237428c68d8"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "/content/SystolicArray/src/python\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x700 with 3 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "#@markdown Click the ▷ button to start the demonstration with your image\n",
+        "\n",
+        "%cd /content/SystolicArray/src/python/\n",
+        "import cv2\n",
+        "from matplotlib import pyplot as plt\n",
+        "if not UPLOADED:\n",
+        "    print(\"First, upload a jpg in the cell above\")\n",
+        "else:\n",
+        "    !python3 full_flow.py userinput\n",
+        "    #@markdown Because the hardware is limited to 8 bit integer math, the output is not as bright as the software version, but it is still able to achieve a similar looking result\n",
+        "\n",
+        "\n",
+        "    # code for displaying multiple images in one figure\n",
+        "\n",
+        "\n",
+        "    # create figure\n",
+        "    fig = plt.figure(figsize=(10, 7))\n",
+        "\n",
+        "    # setting values to rows and column variables\n",
+        "    rows = 1\n",
+        "    columns = 3\n",
+        "\n",
+        "    # reading images\n",
+        "    Image1 = cv2.imread('/content/SystolicArray/src/python/uploadedimage.jpg')\n",
+        "    Image2 = cv2.imread('/content/SystolicArray/src/python/edge_uploadedimage.jpg')\n",
+        "    Image3 = cv2.imread('/content/SystolicArray/src/python/edge_uploadedimage_sa.jpg')\n",
+        "\n",
+        "    #Adds a subplot at the 1st position\n",
+        "    fig.add_subplot(rows, columns, 1)\n",
+        "\n",
+        "    # showing image\n",
+        "    plt.imshow(Image1)\n",
+        "    plt.axis('off')\n",
+        "    plt.title(\"Original\")\n",
+        "\n",
+        "    # Adds a subplot at the 2nd position\n",
+        "    fig.add_subplot(rows, columns, 2)\n",
+        "\n",
+        "    # showing image\n",
+        "    plt.imshow(Image2)\n",
+        "    plt.axis('off')\n",
+        "    plt.title(\"Software Edge Detection\")\n",
+        "\n",
+        "    # Adds a subplot at the 3rd position\n",
+        "    fig.add_subplot(rows, columns, 3)\n",
+        "\n",
+        "    # showing image\n",
+        "    plt.imshow(Image3)\n",
+        "    plt.axis('off')\n",
+        "    plt.title(\"Systolic Array Edge Detection\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FeDMr6K6BMgJ"
+      },
+      "source": [
+        "### RTL2GDS Flow"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@markdown We need to remove the previously installed version of Verilator and also install libparse in order for OpenLane to function properly. In order for everything to run the first time in the notebook we will also need to restart the runtime. Once you click the ▷ button for this cell, at the bottom it will prompt you **Once deleted, variables cannot be recovered. Proceed (y/[n])?** Please type y\n",
+        "!apt remove -y verilator\n",
+        "!pip install libparse\n",
+        "%reset"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xY2thuIDURi7",
+        "outputId": "2ba8a375-25d5-4614-a5bc-00fe55ab3420",
+        "cellView": "form"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Reading package lists... Done\n",
+            "Building dependency tree... Done\n",
+            "Reading state information... Done\n",
+            "Package 'verilator' is not installed, so not removed\n",
+            "The following packages were automatically installed and are no longer required:\n",
+            "  libsystemc libsystemc-dev\n",
+            "Use 'apt autoremove' to remove them.\n",
+            "0 upgraded, 0 newly installed, 0 to remove and 45 not upgraded.\n",
+            "Requirement already satisfied: libparse in ./conda-env/lib/python3.7/site-packages (0.3.1)\n",
+            "Requirement already satisfied: wheel in ./conda-env/lib/python3.7/site-packages (from libparse) (0.38.4)\n",
+            "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
+            "\u001b[0mOnce deleted, variables cannot be recovered. Proceed (y/[n])? y\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Y6snMoxpslsr",
+        "outputId": "3db41f66-6e1d-4252-a26f-e9abb77d7227"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Reading package lists... Done\n",
+            "Building dependency tree... Done\n",
+            "Reading state information... Done\n",
+            "Package 'verilator' is not installed, so not removed\n",
+            "The following packages were automatically installed and are no longer required:\n",
+            "  libsystemc libsystemc-dev\n",
+            "Use 'apt autoremove' to remove them.\n",
+            "0 upgraded, 0 newly installed, 0 to remove and 45 not upgraded.\n",
+            "Empty environment created at prefix: /content/conda-env\n",
+            "\n",
+            "Pinned packages:\n",
+            "  - python 3.7*\n",
+            "\n",
+            "\n",
+            "Transaction\n",
+            "\n",
+            "  Prefix: /content/conda-env\n",
+            "\n",
+            "  Updating specs:\n",
+            "\n",
+            "   - openlane=2023.11.03_0_gf4f8dad8\n",
+            "   - open_pdks.sky130a=1.0.458_0_g8c68aca\n",
+            "   - openroad=2.0_10927_g0922eecb9\n",
+            "   - verilator=5.018_57_ga022b672a\n",
+            "\n",
+            "\n",
+            "  Package                                                Version  Build                 Channel         Size\n",
+            "──────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+            "  Install:\n",
+            "──────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+            "\n",
+            "  \u001b[32m+ open_pdks.sky130a                   \u001b[0m      1.0.458_0_g8c68aca  20231104_052339       litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ _libgcc_mutex                       \u001b[0m                     0.1  main                  main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libstdcxx-ng                        \u001b[0m                  11.2.0  h1234567_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ ca-certificates                     \u001b[0m               2024.3.11  h06a4308_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libstdcxx-devel_linux-64            \u001b[0m                  11.2.0  h1234567_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libgcc-devel_linux-64               \u001b[0m                  11.2.0  h1234567_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ ld_impl_linux-64                    \u001b[0m                    2.38  h1181459_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libgomp                             \u001b[0m                  11.2.0  h1234567_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ _openmp_mutex                       \u001b[0m                     5.1  1_gnu                 main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libgcc-ng                           \u001b[0m                  11.2.0  h1234567_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libuuid                             \u001b[0m                  1.41.5  h5eee18b_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ yaml                                \u001b[0m                   0.1.7  had09818_2            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ gmp                                 \u001b[0m                   6.2.1  h295c915_3            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ lz4-c                               \u001b[0m                   1.9.4  h6a678d5_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ bzip2                               \u001b[0m                   1.0.8  h5eee18b_5            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libev                               \u001b[0m                    4.33  h7f8727e_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ c-ares                              \u001b[0m                  1.19.1  h5eee18b_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libffi                              \u001b[0m                   3.4.4  h6a678d5_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ fmt                                 \u001b[0m                   8.1.1  hd09550d_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ xz                                  \u001b[0m                   5.4.6  h5eee18b_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ pixman                              \u001b[0m                  0.40.0  h7f8727e_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ ncurses                             \u001b[0m                     6.4  h6a678d5_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ openssl                             \u001b[0m                  1.1.1w  h7f8727e_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libxcb                              \u001b[0m                    1.15  h7f8727e_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ jpeg                                \u001b[0m                      9e  h5eee18b_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ icu                                 \u001b[0m                    58.2  he6710b0_3            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libiconv                            \u001b[0m                    1.16  h7f8727e_2            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ expat                               \u001b[0m                   2.5.0  h6a678d5_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ m4                                  \u001b[0m                  1.4.18  h4e445db_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ zlib                                \u001b[0m                  1.2.13  h5eee18b_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ spdlog                              \u001b[0m                   1.9.2  hd09550d_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libedit                             \u001b[0m            3.1.20230828  h5eee18b_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ readline                            \u001b[0m                     8.2  h5eee18b_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libssh2                             \u001b[0m                  1.10.0  h37d81fd_2            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ flex                                \u001b[0m                   2.6.4  ha10e3a4_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ zstd                                \u001b[0m                   1.5.5  hc292b87_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libnghttp2                          \u001b[0m                  1.52.0  ha637b67_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libpng                              \u001b[0m                  1.6.39  h5eee18b_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ pcre2                               \u001b[0m                   10.42  hebb0a14_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ tk                                  \u001b[0m                  8.6.12  h1ccaba5_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ krb5                                \u001b[0m                  1.20.1  h568e23c_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ sqlite                              \u001b[0m                  3.41.2  h5eee18b_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ bison                               \u001b[0m                   3.7.5  h2531618_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libboost                            \u001b[0m                  1.73.0  h28710b8_12           main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ freetype                            \u001b[0m                  2.12.1  h4a9f257_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libglib                             \u001b[0m                  2.78.4  hdc74915_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ ruby                                \u001b[0m                   2.5.1  haf1161a_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libcurl                             \u001b[0m                   8.2.1  h91b91d3_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ python                              \u001b[0m                  3.7.16  h7a1cb2a_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ glib-tools                          \u001b[0m                  2.78.4  h6a678d5_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ curl                                \u001b[0m                   8.2.1  h37d81fd_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ certifi                             \u001b[0m               2022.12.7  py37h06a4308_0        main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ wheel                               \u001b[0m                  0.38.4  py37h06a4308_0        main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libgit2                             \u001b[0m                   1.6.4  ha637b67_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ setuptools                          \u001b[0m                  65.6.3  py37h06a4308_0        main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ pip                                 \u001b[0m                  22.3.1  py37h06a4308_0        main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ pyyaml                              \u001b[0m                   5.3.1  py37h7b6447c_0        main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ zipp                                \u001b[0m                  3.11.0  py37h06a4308_0        main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ glib                                \u001b[0m                  2.78.4  h6a678d5_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ gstreamer                           \u001b[0m                  1.14.1  h5eee18b_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ dbus                                \u001b[0m                 1.13.18  hb2f20db_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ gst-plugins-base                    \u001b[0m                  1.14.1  h6a678d5_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ _sysroot_linux-64_curr_repodata_hack\u001b[0m                       3  haa98f57_10           main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ flit-core                           \u001b[0m                   3.6.0  pyhd3eb1b0_0          main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ kernel-headers_linux-64             \u001b[0m                  3.10.0  h57e8cba_10           main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ sysroot_linux-64                    \u001b[0m                    2.17  h57e8cba_10           main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ libxml2                             \u001b[0m                   2.9.9  20220706_155948       litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ netgen                              \u001b[0m      1.5.272_0_g178af5f  20240223_100318       litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ yosys                               \u001b[0m      0.38_93_g84116c9a3  20240223_100318_py37  litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ tcllib                              \u001b[0m     1_21_150_g102aa4b6e  20240223_100318       litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ typing_extensions                   \u001b[0m                   4.4.0  py37h06a4308_0        main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ binutils_impl_linux-64              \u001b[0m                    2.38  h2a08ee3_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ fontconfig                          \u001b[0m                  2.13.0  h9420a91_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ importlib-metadata                  \u001b[0m                  4.11.3  py37h06a4308_0        main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ gcc_impl_linux-64                   \u001b[0m                  11.2.0  h1234567_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ binutils_linux-64                   \u001b[0m                  2.38.0  hc2dff05_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ cairo                               \u001b[0m                 1.14.12  h8948797_3            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ qt                                  \u001b[0m                   5.9.7  h5867ecd_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ click                               \u001b[0m                   8.0.4  py37h06a4308_0        main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ gxx_impl_linux-64                   \u001b[0m                  11.2.0  h1234567_1            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ gcc_linux-64                        \u001b[0m                  11.2.0  h5c386dc_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ gxx_linux-64                        \u001b[0m                  11.2.0  hc2dff05_0            main     \u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ magic                               \u001b[0m      8.3.450_0_g2133660  20231104_052339       litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ klayout                             \u001b[0m  0.28.17_212_gfa14afbbf  20240223_100318_py37  litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ openroad                            \u001b[0m    2.0_10927_g0922eecb9  20231104_052339_py37  litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ verilator                           \u001b[0m     5.018_57_ga022b672a  20231104_052339       litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "  \u001b[32m+ openlane                            \u001b[0m  2023.11.03_0_gf4f8dad8  20231104_052339_py37  litex-hub\u001b[32m     Cached\u001b[0m\n",
+            "\n",
+            "  Summary:\n",
+            "\n",
+            "  Install: 87 packages\n",
+            "\n",
+            "  Total download: 0 B\n",
+            "\n",
+            "──────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+            "\n",
+            "\n",
+            "\n",
+            "Transaction starting\n",
+            "Linking open_pdks.sky130a-1.0.458_0_g8c68aca-20231104_052339\n",
+            "Linking _libgcc_mutex-0.1-main\n",
+            "Linking libstdcxx-ng-11.2.0-h1234567_1\n",
+            "Linking ca-certificates-2024.3.11-h06a4308_0\n",
+            "Linking libstdcxx-devel_linux-64-11.2.0-h1234567_1\n",
+            "Linking libgcc-devel_linux-64-11.2.0-h1234567_1\n",
+            "Linking ld_impl_linux-64-2.38-h1181459_1\n",
+            "Linking libgomp-11.2.0-h1234567_1\n",
+            "Linking _openmp_mutex-5.1-1_gnu\n",
+            "Linking libgcc-ng-11.2.0-h1234567_1\n",
+            "Linking libuuid-1.41.5-h5eee18b_0\n",
+            "Linking yaml-0.1.7-had09818_2\n",
+            "Linking gmp-6.2.1-h295c915_3\n",
+            "Linking lz4-c-1.9.4-h6a678d5_0\n",
+            "Linking bzip2-1.0.8-h5eee18b_5\n",
+            "Linking libev-4.33-h7f8727e_1\n",
+            "Linking c-ares-1.19.1-h5eee18b_0\n",
+            "Linking libffi-3.4.4-h6a678d5_0\n",
+            "Linking fmt-8.1.1-hd09550d_1\n",
+            "Linking xz-5.4.6-h5eee18b_0\n",
+            "Linking pixman-0.40.0-h7f8727e_1\n",
+            "Linking ncurses-6.4-h6a678d5_0\n",
+            "Linking openssl-1.1.1w-h7f8727e_0\n",
+            "Linking libxcb-1.15-h7f8727e_0\n",
+            "Linking jpeg-9e-h5eee18b_1\n",
+            "Linking icu-58.2-he6710b0_3\n",
+            "Linking libiconv-1.16-h7f8727e_2\n",
+            "Linking expat-2.5.0-h6a678d5_0\n",
+            "Linking m4-1.4.18-h4e445db_0\n",
+            "Linking zlib-1.2.13-h5eee18b_0\n",
+            "Linking spdlog-1.9.2-hd09550d_0\n",
+            "Linking libedit-3.1.20230828-h5eee18b_0\n",
+            "Linking readline-8.2-h5eee18b_0\n",
+            "Linking libssh2-1.10.0-h37d81fd_2\n",
+            "Linking flex-2.6.4-ha10e3a4_1\n",
+            "Linking zstd-1.5.5-hc292b87_0\n",
+            "Linking libnghttp2-1.52.0-ha637b67_1\n",
+            "Linking libpng-1.6.39-h5eee18b_0\n",
+            "Linking pcre2-10.42-hebb0a14_0\n",
+            "Linking tk-8.6.12-h1ccaba5_0\n",
+            "Linking krb5-1.20.1-h568e23c_1\n",
+            "Linking sqlite-3.41.2-h5eee18b_0\n",
+            "Linking bison-3.7.5-h2531618_1\n",
+            "Linking libboost-1.73.0-h28710b8_12\n",
+            "Linking freetype-2.12.1-h4a9f257_0\n",
+            "Linking libglib-2.78.4-hdc74915_0\n",
+            "Linking ruby-2.5.1-haf1161a_0\n",
+            "Linking libcurl-8.2.1-h91b91d3_0\n",
+            "Linking python-3.7.16-h7a1cb2a_0\n",
+            "Linking glib-tools-2.78.4-h6a678d5_0\n",
+            "Linking curl-8.2.1-h37d81fd_0\n",
+            "Linking certifi-2022.12.7-py37h06a4308_0\n",
+            "Linking wheel-0.38.4-py37h06a4308_0\n",
+            "Linking libgit2-1.6.4-ha637b67_0\n",
+            "Linking setuptools-65.6.3-py37h06a4308_0\n",
+            "Linking pip-22.3.1-py37h06a4308_0\n",
+            "Linking pyyaml-5.3.1-py37h7b6447c_0\n",
+            "Linking zipp-3.11.0-py37h06a4308_0\n",
+            "Linking glib-2.78.4-h6a678d5_0\n",
+            "Linking gstreamer-1.14.1-h5eee18b_1\n",
+            "Linking dbus-1.13.18-hb2f20db_0\n",
+            "Linking gst-plugins-base-1.14.1-h6a678d5_1\n",
+            "Linking _sysroot_linux-64_curr_repodata_hack-3-haa98f57_10\n",
+            "Linking flit-core-3.6.0-pyhd3eb1b0_0\n",
+            "Linking kernel-headers_linux-64-3.10.0-h57e8cba_10\n",
+            "Linking sysroot_linux-64-2.17-h57e8cba_10\n",
+            "Linking libxml2-2.9.9-20220706_155948\n",
+            "Linking netgen-1.5.272_0_g178af5f-20240223_100318\n",
+            "Linking yosys-0.38_93_g84116c9a3-20240223_100318_py37\n",
+            "Linking tcllib-1_21_150_g102aa4b6e-20240223_100318\n",
+            "Linking typing_extensions-4.4.0-py37h06a4308_0\n",
+            "Linking binutils_impl_linux-64-2.38-h2a08ee3_1\n",
+            "\u001b[33m\u001b[1mwarning  libmamba\u001b[m [binutils_impl_linux-64-2.38-h2a08ee3_1] The following files were already present in the environment:\n",
+            "    - lib/liblsan.so\n",
+            "    - lib/liblsan.so.0\n",
+            "    - lib/liblsan.so.0.0.0\n",
+            "    - share/info/libgomp.info\n",
+            "    - share/info/libquadmath.info\n",
+            "    - share/licenses/gcc-libs/RUNTIME.LIBRARY.EXCEPTION\n",
+            "    - share/licenses/gcc-libs/RUNTIME.LIBRARY.EXCEPTION.gomp_copy\n",
+            "    - share/licenses/libstdc++/RUNTIME.LIBRARY.EXCEPTION\n",
+            "Linking fontconfig-2.13.0-h9420a91_0\n",
+            "Linking importlib-metadata-4.11.3-py37h06a4308_0\n",
+            "Linking gcc_impl_linux-64-11.2.0-h1234567_1\n",
+            "Linking binutils_linux-64-2.38.0-hc2dff05_0\n",
+            "Linking cairo-1.14.12-h8948797_3\n",
+            "Linking qt-5.9.7-h5867ecd_1\n",
+            "Linking click-8.0.4-py37h06a4308_0\n",
+            "Linking gxx_impl_linux-64-11.2.0-h1234567_1\n",
+            "Linking gcc_linux-64-11.2.0-h5c386dc_0\n",
+            "Linking gxx_linux-64-11.2.0-hc2dff05_0\n",
+            "Linking magic-8.3.450_0_g2133660-20231104_052339\n",
+            "Linking klayout-0.28.17_212_gfa14afbbf-20240223_100318_py37\n",
+            "Linking openroad-2.0_10927_g0922eecb9-20231104_052339_py37\n",
+            "Linking verilator-5.018_57_ga022b672a-20231104_052339\n",
+            "Linking openlane-2023.11.03_0_gf4f8dad8-20231104_052339_py37\n",
+            "\n",
+            "Transaction finished\n",
+            "\n",
+            "To activate this environment, use:\n",
+            "\n",
+            "    micromamba activate /content/conda-env\n",
+            "\n",
+            "Or to execute a single command in this environment, use:\n",
+            "\n",
+            "    micromamba run -p /content/conda-env mycommand\n",
+            "\n",
+            "\u001b[33m\u001b[1mwarning  libmamba\u001b[m [libblas-3.9.0-16_linux64_openblas] The following files were already present in the environment:\n",
+            "    - lib/libblas.so\n",
+            "\u001b[33m\u001b[1mwarning  libmamba\u001b[m [libcblas-3.9.0-16_linux64_openblas] The following files were already present in the environment:\n",
+            "    - lib/libcblas.so\n",
+            "\u001b[33m\u001b[1mwarning  libmamba\u001b[m [liblapack-3.9.0-16_linux64_openblas] The following files were already present in the environment:\n",
+            "    - lib/liblapack.so\n",
+            "Collecting libparse\n",
+            "  Using cached libparse-0.3.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.0 MB)\n",
+            "Requirement already satisfied: wheel in ./conda-env/lib/python3.7/site-packages (from libparse) (0.38.4)\n",
+            "Installing collected packages: libparse\n",
+            "Successfully installed libparse-0.3.1\n",
+            "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
+            "\u001b[0menv: CONDA_PREFIX=/content/conda-env\n",
+            "env: PATH=/content/conda-env/bin:/content/conda-env/bin:/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin\n"
+          ]
+        }
+      ],
+      "source": [
+        "#@title Install Dependencies {display-mode: \"form\"}\n",
+        "#@markdown Click the ▷ button to setup the digital design environment based on [conda-eda](https://github.com/hdl/conda-eda).\n",
+        "\n",
+        "#@markdown Main components we will install\n",
+        "\n",
+        "#@markdown *   Open_pdks.sky130a : a PDK installer for open-source EDA tools.\n",
+        "#@markdown *   Openlane : an automated RTL to GDSII flow based on several components including OpenROAD, Yosys, Magic, Netgen, CVC, SPEF-Extractor, KLayout and a number of custom scripts for design exploration and optimization.\n",
+        "#@markdown *   GDSTK : a C++ library for creation and manipulation of GDSII and OASIS files.\n",
+        "\n",
+        "!apt remove -y verilator\n",
+        "#openlane_version = 'custom_set' #@param {type:\"string\"}\n",
+        "#open_pdks_version = 'custom_set' #@param {type:\"string\"}\n",
+        "\n",
+        "#if openlane_version == 'latest':\n",
+        "#  openlane_version = ''\n",
+        "#if open_pdks_version == 'latest':\n",
+        "#  open_pdks_version = ''\n",
+        "\n",
+        "import os\n",
+        "import pathlib\n",
+        "\n",
+        "!curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj bin/micromamba\n",
+        "conda_prefix_path = pathlib.Path('conda-env')\n",
+        "CONDA_PREFIX = str(conda_prefix_path.resolve())\n",
+        "!bin/micromamba create --yes --prefix $CONDA_PREFIX\n",
+        "!echo 'python ==3.7*' >> {CONDA_PREFIX}/conda-meta/pinned\n",
+        "!CI=0 bin/micromamba install --yes --prefix $CONDA_PREFIX \\\n",
+        "                     --channel litex-hub \\\n",
+        "                     --channel main \\\n",
+        "                     openlane={\"2023.11.03_0_gf4f8dad8\"} \\\n",
+        "                     open_pdks.sky130a={\"1.0.458_0_g8c68aca\"} \\\n",
+        "                     openroad={\"2.0_10927_g0922eecb9\"} \\\n",
+        "                     verilator={\"5.018_57_ga022b672a\"}\n",
+        "!bin/micromamba install --quiet \\\n",
+        "                        --yes \\\n",
+        "                        --prefix $CONDA_PREFIX \\\n",
+        "                        --channel conda-forge \\\n",
+        "                        --channel main \\\n",
+        "                        gdstk\n",
+        "\n",
+        "!pip install libparse libparse\n",
+        "PATH = os.environ['PATH']\n",
+        "%env CONDA_PREFIX={CONDA_PREFIX}\n",
+        "%env PATH={CONDA_PREFIX}/bin:{PATH}\n",
+        "#%reset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "2JPlqKcqZjg8",
+        "outputId": "6dfd44e3-143a-4559-bfe9-54437a8f114b"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Overwriting config.json\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile config.json\n",
+        "{\n",
+        "    \"DESIGN_NAME\": \"top\",\n",
+        "    \"VERILOG_FILES\": \"dir::SystolicArray/src/*.sv\",\n",
+        "    \"CLOCK_PERIOD\": 40,\n",
+        "    \"CLOCK_NET\": \"clk\",\n",
+        "    \"CLOCK_PORT\": \"clk\",\n",
+        "\n",
+        "    \"FP_SIZING\": \"absolute\",\n",
+        "    \"DIE_AREA\": \"0 0 480 200\",\n",
+        "    \"PL_TARGET_DENSITY\": 0.8\n",
+        "}"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Run Flow\n",
+        "In the event that the flow fails due to a verilator (linter) or libparse (on step 34) error please restart runtime and rerun install dependencies. Just re-running install dependencies may work as well"
+      ],
+      "metadata": {
+        "id": "2fgWsyDvzvgD"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "pgpxBIVAaSIo",
+        "outputId": "1293ffa6-c504-4680-adb8-bb3f31eae7cf"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "env: PDK=sky130A\n",
+            "OpenLane 2023.11.03_0_gf4f8dad8-conda\n",
+            "All rights reserved. (c) 2020-2022 Efabless Corporation and contributors.\n",
+            "Available under the Apache License, version 2.0. See the LICENSE file for more details.\n",
+            "\n",
+            "\u001b[36m[INFO]: Using configuration in 'config.json'...\u001b[39m\n",
+            "\u001b[36m[INFO]: PDK Root: /content/conda-env/share/pdk\u001b[39m\n",
+            "\u001b[36m[INFO]: Process Design Kit: sky130A\u001b[39m\n",
+            "\u001b[36m[INFO]: Standard Cell Library: sky130_fd_sc_hd\u001b[39m\n",
+            "\u001b[36m[INFO]: Optimization Standard Cell Library: sky130_fd_sc_hd\u001b[39m\n",
+            "\u001b[36m[INFO]: Run Directory: /content/runs/RUN_2024.04.15_18.01.03\u001b[39m\n",
+            "\u001b[36m[INFO]: Saving runtime environment...\u001b[39m\n",
+            "\u001b[36m[INFO]: Preparing LEF files for the nom corner...\u001b[39m\n",
+            "\u001b[36m[INFO]: Preparing LEF files for the min corner...\u001b[39m\n",
+            "\u001b[36m[INFO]: Preparing LEF files for the max corner...\u001b[39m\n",
+            "\u001b[33m[WARNING]: PNR_SDC_FILE is not set. It is recommended to write a custom SDC file for the design. Defaulting to BASE_SDC_FILE\u001b[39m\n",
+            "\u001b[33m[WARNING]: SIGNOFF_SDC_FILE is not set. It is recommended to write a custom SDC file for the design. Defaulting to BASE_SDC_FILE\u001b[39m\n",
+            "\u001b[36m[INFO]: Running linter (Verilator) (log: runs/RUN_2024.04.15_18.01.03/logs/synthesis/linter.log)...\u001b[39m\n",
+            "\u001b[36m[INFO]: 0 errors found by linter\u001b[39m\n",
+            "\u001b[33m[WARNING]: 10 warnings found by linter\u001b[39m\n",
+            "[STEP 1]\n",
+            "\u001b[36m[INFO]: Running Synthesis (log: runs/RUN_2024.04.15_18.01.03/logs/synthesis/1-synthesis.log)...\u001b[39m\n",
+            "[STEP 2]\n",
+            "\u001b[36m[INFO]: Running Single-Corner Static Timing Analysis (log: runs/RUN_2024.04.15_18.01.03/logs/synthesis/2-sta.log)...\u001b[39m\n",
+            "[STEP 3]\n",
+            "\u001b[36m[INFO]: Running Initial Floorplanning (log: runs/RUN_2024.04.15_18.01.03/logs/floorplan/3-initial_fp.log)...\u001b[39m\n",
+            "\u001b[36m[INFO]: Floorplanned with width 468.74 and height 176.8.\u001b[39m\n",
+            "[STEP 4]\n",
+            "\u001b[36m[INFO]: Running IO Placement (log: runs/RUN_2024.04.15_18.01.03/logs/floorplan/4-io.log)...\u001b[39m\n",
+            "[STEP 5]\n",
+            "\u001b[36m[INFO]: Running Tap/Decap Insertion (log: runs/RUN_2024.04.15_18.01.03/logs/floorplan/5-tap.log)...\u001b[39m\n",
+            "\u001b[36m[INFO]: Power planning with power {VPWR} and ground {VGND}...\u001b[39m\n",
+            "[STEP 6]\n",
+            "\u001b[36m[INFO]: Generating PDN (log: runs/RUN_2024.04.15_18.01.03/logs/floorplan/6-pdn.log)...\u001b[39m\n",
+            "[STEP 7]\n",
+            "\u001b[36m[INFO]: Running Global Placement (log: runs/RUN_2024.04.15_18.01.03/logs/placement/7-global_skip_io.log)...\u001b[39m\n",
+            "[STEP 8]\n",
+            "\u001b[36m[INFO]: Running Single-Corner Static Timing Analysis (log: runs/RUN_2024.04.15_18.01.03/logs/placement/8-gpl_sta.log)...\u001b[39m\n",
+            "[STEP 9]\n",
+            "\u001b[36m[INFO]: Running IO Placement (log: runs/RUN_2024.04.15_18.01.03/logs/placement/9-io.log)...\u001b[39m\n",
+            "[STEP 10]\n",
+            "\u001b[36m[INFO]: Running Global Placement (log: runs/RUN_2024.04.15_18.01.03/logs/placement/10-global.log)...\u001b[39m\n",
+            "[STEP 11]\n",
+            "\u001b[36m[INFO]: Running Single-Corner Static Timing Analysis (log: runs/RUN_2024.04.15_18.01.03/logs/placement/11-gpl_sta.log)...\u001b[39m\n",
+            "[STEP 12]\n",
+            "\u001b[36m[INFO]: Running Placement Resizer Design Optimizations (log: runs/RUN_2024.04.15_18.01.03/logs/placement/12-resizer.log)...\u001b[39m\n",
+            "[STEP 13]\n",
+            "\u001b[36m[INFO]: Running Detailed Placement (log: runs/RUN_2024.04.15_18.01.03/logs/placement/13-detailed.log)...\u001b[39m\n",
+            "[STEP 14]\n",
+            "\u001b[36m[INFO]: Running Single-Corner Static Timing Analysis (log: runs/RUN_2024.04.15_18.01.03/logs/placement/14-dpl_sta.log)...\u001b[39m\n",
+            "[STEP 15]\n",
+            "\u001b[36m[INFO]: Running Clock Tree Synthesis (log: runs/RUN_2024.04.15_18.01.03/logs/cts/15-cts.log)...\u001b[39m\n",
+            "[STEP 16]\n",
+            "\u001b[36m[INFO]: Running Single-Corner Static Timing Analysis (log: runs/RUN_2024.04.15_18.01.03/logs/cts/16-cts_sta.log)...\u001b[39m\n",
+            "[STEP 17]\n",
+            "\u001b[36m[INFO]: Running Placement Resizer Timing Optimizations (log: runs/RUN_2024.04.15_18.01.03/logs/cts/17-resizer.log)...\u001b[39m\n",
+            "[STEP 18]\n",
+            "\u001b[36m[INFO]: Running Global Routing Resizer Design Optimizations (log: runs/RUN_2024.04.15_18.01.03/logs/routing/18-resizer_design.log)...\u001b[39m\n",
+            "[STEP 19]\n",
+            "\u001b[36m[INFO]: Running Single-Corner Static Timing Analysis (log: runs/RUN_2024.04.15_18.01.03/logs/routing/19-rsz_design_sta.log)...\u001b[39m\n",
+            "[STEP 20]\n",
+            "\u001b[36m[INFO]: Running Global Routing Resizer Timing Optimizations (log: runs/RUN_2024.04.15_18.01.03/logs/routing/20-resizer_timing.log)...\u001b[39m\n",
+            "[STEP 21]\n",
+            "\u001b[36m[INFO]: Running Single-Corner Static Timing Analysis (log: runs/RUN_2024.04.15_18.01.03/logs/routing/21-rsz_timing_sta.log)...\u001b[39m\n",
+            "[STEP 22]\n",
+            "\u001b[36m[INFO]: Running Global Routing (log: runs/RUN_2024.04.15_18.01.03/logs/routing/22-global.log)...\u001b[39m\n",
+            "\u001b[36m[INFO]: Starting OpenROAD Antenna Repair Iterations...\u001b[39m\n",
+            "[STEP 23]\n",
+            "\u001b[36m[INFO]: Writing Verilog (log: runs/RUN_2024.04.15_18.01.03/logs/routing/22-global_write_netlist.log)...\u001b[39m\n",
+            "[STEP 24]\n",
+            "\u001b[36m[INFO]: Running Single-Corner Static Timing Analysis (log: runs/RUN_2024.04.15_18.01.03/logs/routing/24-grt_sta.log)...\u001b[39m\n",
+            "[STEP 25]\n",
+            "\u001b[36m[INFO]: Running Fill Insertion (log: runs/RUN_2024.04.15_18.01.03/logs/routing/25-fill.log)...\u001b[39m\n",
+            "[STEP 26]\n",
+            "\u001b[36m[INFO]: Running Detailed Routing (log: runs/RUN_2024.04.15_18.01.03/logs/routing/26-detailed.log)...\u001b[39m\n",
+            "\u001b[36m[INFO]: No DRC violations after detailed routing.\u001b[39m\n",
+            "[STEP 27]\n",
+            "\u001b[36m[INFO]: Checking Wire Lengths (log: runs/RUN_2024.04.15_18.01.03/logs/routing/27-wire_lengths.log)...\u001b[39m\n",
+            "[STEP 28]\n",
+            "\u001b[36m[INFO]: Running SPEF Extraction at the min process corner (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/28-parasitics_extraction.min.log)...\u001b[39m\n",
+            "[STEP 29]\n",
+            "\u001b[36m[INFO]: Running Multi-Corner Static Timing Analysis at the min process corner (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/29-rcx_mcsta.min.log)...\u001b[39m\n",
+            "[STEP 30]\n",
+            "\u001b[36m[INFO]: Running SPEF Extraction at the max process corner (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/30-parasitics_extraction.max.log)...\u001b[39m\n",
+            "[STEP 31]\n",
+            "\u001b[36m[INFO]: Running Multi-Corner Static Timing Analysis at the max process corner (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/31-rcx_mcsta.max.log)...\u001b[39m\n",
+            "[STEP 32]\n",
+            "\u001b[36m[INFO]: Running SPEF Extraction at the nom process corner (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/32-parasitics_extraction.nom.log)...\u001b[39m\n",
+            "[STEP 33]\n",
+            "\u001b[36m[INFO]: Running Multi-Corner Static Timing Analysis at the nom process corner (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/33-rcx_mcsta.nom.log)...\u001b[39m\n",
+            "\u001b[33m[WARNING]: Module sky130_fd_sc_hd__tapvpwrvgnd_1 blackboxed during sta\u001b[39m\n",
+            "\u001b[33m[WARNING]: Module sky130_ef_sc_hd__decap_12 blackboxed during sta\u001b[39m\n",
+            "\u001b[33m[WARNING]: Module sky130_fd_sc_hd__fill_1 blackboxed during sta\u001b[39m\n",
+            "\u001b[33m[WARNING]: Module sky130_fd_sc_hd__fill_2 blackboxed during sta\u001b[39m\n",
+            "[STEP 34]\n",
+            "\u001b[36m[INFO]: Creating IR Drop Report (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/34-irdrop.log)...\u001b[39m\n",
+            "\u001b[33m[WARNING]: VSRC_LOC_FILES is not defined. The IR drop analysis will run, but the values may be inaccurate.\u001b[39m\n",
+            "[STEP 35]\n",
+            "\u001b[36m[INFO]: Running Magic to generate various views...\u001b[39m\n",
+            "\u001b[36m[INFO]: Streaming out GDSII with Magic (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/35-gdsii.log)...\u001b[39m\n",
+            "\u001b[36m[INFO]: Generating MAGLEF views...\u001b[39m\n",
+            "\u001b[36m[INFO]: Generating lef with Magic (/content/runs/RUN_2024.04.15_18.01.03/logs/signoff/35-lef.log)...\u001b[39m\n",
+            "[STEP 36]\n",
+            "\u001b[36m[INFO]: Streaming out GDSII with KLayout (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/36-gdsii-klayout.log)...\u001b[39m\n",
+            "\u001b[33m[WARNING]: 'runs/RUN_2024.04.15_18.01.03/results/signoff/top.klayout.gds' wasn't found. Skipping GDS XOR.\u001b[39m\n",
+            "[STEP 37]\n",
+            "\u001b[36m[INFO]: Running Magic Spice Export from LEF (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/37-spice.log)...\u001b[39m\n",
+            "[STEP 38]\n",
+            "\u001b[36m[INFO]: Writing Powered Verilog (logs: runs/RUN_2024.04.15_18.01.03/logs/signoff/38-write_powered_def.log, runs/RUN_2024.04.15_18.01.03/logs/signoff/38-write_powered_verilog.log)...\u001b[39m\n",
+            "[STEP 39]\n",
+            "\u001b[36m[INFO]: Writing Verilog (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/38-write_powered_verilog.log)...\u001b[39m\n",
+            "[STEP 40]\n",
+            "\u001b[36m[INFO]: Running LVS (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/40-lvs.lef.log)...\u001b[39m\n",
+            "[STEP 41]\n",
+            "\u001b[36m[INFO]: Running Magic DRC (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/41-drc.log)...\u001b[39m\n",
+            "\u001b[36m[INFO]: Converting Magic DRC database to various tool-readable formats...\u001b[39m\n",
+            "\u001b[36m[INFO]: No DRC violations after GDS streaming out.\u001b[39m\n",
+            "[STEP 42]\n",
+            "\u001b[36m[INFO]: Running OpenROAD Antenna Rule Checker (log: runs/RUN_2024.04.15_18.01.03/logs/signoff/42-arc.log)...\u001b[39m\n",
+            "\u001b[36m[INFO]: Saving current set of views in 'runs/RUN_2024.04.15_18.01.03/results/final'...\u001b[39m\n",
+            "\u001b[36m[INFO]: Saving runtime environment...\u001b[39m\n",
+            "\u001b[36m[INFO]: Generating final set of reports...\u001b[39m\n",
+            "\u001b[36m[INFO]: Created manufacturability report at 'runs/RUN_2024.04.15_18.01.03/reports/manufacturability.rpt'.\u001b[39m\n",
+            "\u001b[36m[INFO]: Created metrics report at 'runs/RUN_2024.04.15_18.01.03/reports/metrics.csv'.\u001b[39m\n",
+            "\u001b[33m[WARNING]: There are max fanout violations in the design at the Typical corner. Please refer to 'runs/RUN_2024.04.15_18.01.03/reports/signoff/33-sta-rcx_nom/multi_corner_sta.checks.rpt'.\u001b[39m\n",
+            "\u001b[36m[INFO]: There are no hold violations in the design at the Typical corner.\u001b[39m\n",
+            "\u001b[36m[INFO]: There are no setup violations in the design at the Typical corner.\u001b[39m\n",
+            "\u001b[32m[SUCCESS]: Flow complete.\u001b[39m\n",
+            "\u001b[36m[INFO]: Note that the following warnings have been generated:\u001b[39m\n",
+            "\u001b[33m[WARNING]: PNR_SDC_FILE is not set. It is recommended to write a custom SDC file for the design. Defaulting to BASE_SDC_FILE\n",
+            "[WARNING]: SIGNOFF_SDC_FILE is not set. It is recommended to write a custom SDC file for the design. Defaulting to BASE_SDC_FILE\n",
+            "[WARNING]: 10 warnings found by linter\n",
+            "[WARNING]: Module sky130_fd_sc_hd__tapvpwrvgnd_1 blackboxed during sta\n",
+            "[WARNING]: Module sky130_ef_sc_hd__decap_12 blackboxed during sta\n",
+            "[WARNING]: Module sky130_fd_sc_hd__fill_1 blackboxed during sta\n",
+            "[WARNING]: Module sky130_fd_sc_hd__fill_2 blackboxed during sta\n",
+            "[WARNING]: VSRC_LOC_FILES is not defined. The IR drop analysis will run, but the values may be inaccurate.\n",
+            "[WARNING]: 'runs/RUN_2024.04.15_18.01.03/results/signoff/top.klayout.gds' wasn't found. Skipping GDS XOR.\n",
+            "[WARNING]: There are max fanout violations in the design at the Typical corner. Please refer to 'runs/RUN_2024.04.15_18.01.03/reports/signoff/33-sta-rcx_nom/multi_corner_sta.checks.rpt'.\n",
+            "\u001b[39m\n"
+          ]
+        }
+      ],
+      "source": [
+        "%env PDK=sky130A\n",
+        "!flow.tcl -design ."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "gnz4w7-ofBv4",
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "#@title View Results\n",
+        "#@markdown Click the ▷ button to generate an SVG from the GDS\n",
+        "#@markdown in our testing sometimes the svg does not show or is too large to render properly so we have converted to png offline for viewing. The result is displayed below\n",
+        "import pathlib\n",
+        "import gdstk\n",
+        "\n",
+        "gdss = sorted(pathlib.Path('runs').glob('*/results/final/gds/*.gds'))\n",
+        "library = gdstk.read_gds(gdss[-1])\n",
+        "top_cells = library.top_level()\n",
+        "top_cells[0].write_svg('systolicarray.svg')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "<div>\n",
+        "<img src=\"https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/systolicarray.jpg?raw=true\" width=\"1000\"/>\n",
+        "</div>\n",
+        "\n",
+        "<!-- ![Flow](https://github.com/SiliconJackets/sscs-ose-code-a-chip.github.io/blob/main/VLSI24/submitted_notebooks/SJSystolicArray/img/systolicarray\n",
+        ".png?raw=true){width=250} -->"
+      ],
+      "metadata": {
+        "id": "Le05msrOFkVZ"
+      }
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.9.18"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "0e66c80f52844968a03503ce83a094d3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ButtonModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ButtonView",
+            "button_style": "",
+            "description": "Upload Image",
+            "disabled": false,
+            "icon": "",
+            "layout": "IPY_MODEL_466bae39c60e4d9e959805ad72c5b0ca",
+            "style": "IPY_MODEL_69a7b45aa0c8418dbf29b03f181842f8",
+            "tooltip": ""
+          }
+        },
+        "466bae39c60e4d9e959805ad72c5b0ca": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "69a7b45aa0c8418dbf29b03f181842f8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ButtonStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "button_color": null,
+            "font_weight": ""
+          }
+        },
+        "a190641ce2f2487b9acfc91e931f7ece": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FileUploadModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_counter": 1,
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FileUploadModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "FileUploadView",
+            "accept": ".jpg",
+            "button_style": "",
+            "data": [
+              null
+            ],
+            "description": "Upload",
+            "description_tooltip": null,
+            "disabled": false,
+            "error": "",
+            "icon": "upload",
+            "layout": "IPY_MODEL_dbeebae2d6e54cffb3f2bb1ba751071d",
+            "metadata": [
+              {
+                "name": "Gibbon_Wallpaper.jpg",
+                "type": "image/jpeg",
+                "size": 280843,
+                "lastModified": 1709176092406
+              }
+            ],
+            "multiple": false,
+            "style": "IPY_MODEL_330f9dbba2714e35bcc1335fd74f8dcd"
+          }
+        },
+        "dbeebae2d6e54cffb3f2bb1ba751071d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "330f9dbba2714e35bcc1335fd74f8dcd": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ButtonStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ButtonStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "button_color": null,
+            "font_weight": ""
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/img/Ctrl.png b/VLSI24/submitted_notebooks/SJSystolicArray/img/Ctrl.png
new file mode 100644
index 00000000..946e16c6
Binary files /dev/null and b/VLSI24/submitted_notebooks/SJSystolicArray/img/Ctrl.png differ
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/img/PE.png b/VLSI24/submitted_notebooks/SJSystolicArray/img/PE.png
new file mode 100644
index 00000000..af22ed36
Binary files /dev/null and b/VLSI24/submitted_notebooks/SJSystolicArray/img/PE.png differ
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/img/Top.png b/VLSI24/submitted_notebooks/SJSystolicArray/img/Top.png
new file mode 100644
index 00000000..9d140889
Binary files /dev/null and b/VLSI24/submitted_notebooks/SJSystolicArray/img/Top.png differ
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/img/systolic_array_flow.gif b/VLSI24/submitted_notebooks/SJSystolicArray/img/systolic_array_flow.gif
new file mode 100644
index 00000000..c389ad12
Binary files /dev/null and b/VLSI24/submitted_notebooks/SJSystolicArray/img/systolic_array_flow.gif differ
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/img/systolicarray.jpg b/VLSI24/submitted_notebooks/SJSystolicArray/img/systolicarray.jpg
new file mode 100644
index 00000000..148aecd0
Binary files /dev/null and b/VLSI24/submitted_notebooks/SJSystolicArray/img/systolicarray.jpg differ
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/img/systolicarray.png b/VLSI24/submitted_notebooks/SJSystolicArray/img/systolicarray.png
new file mode 100644
index 00000000..688e0e94
Binary files /dev/null and b/VLSI24/submitted_notebooks/SJSystolicArray/img/systolicarray.png differ
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/src/PE.sv b/VLSI24/submitted_notebooks/SJSystolicArray/src/PE.sv
new file mode 100644
index 00000000..282c6c4e
--- /dev/null
+++ b/VLSI24/submitted_notebooks/SJSystolicArray/src/PE.sv
@@ -0,0 +1,109 @@
+module PE
+    (
+        input logic clk_i, rstn_i,
+        input logic [9:0] psum_i,
+        input logic [7:0] filter_i, 
+        input logic [7:0] ifmap_i, 
+        input logic read_new_filter_val,
+        input logic read_new_ifmap_val,
+        input logic start_conv,
+        output logic [9:0] psum_o, 
+        output logic psum_valid_o
+    );
+
+    //Scratchpad regs
+    logic signed [7:0] filter_spad [0:2];
+    logic signed [7:0] ifmap_spad [0:2];
+    logic signed [9:0] psum_spad;
+    
+    //psum buffer reg
+    logic signed [9:0] psum_buffer;
+
+    //datapath wires
+    // logic signed [DATA_SIZE-1:0] mult_input_filter, mult_input_ifmap; //wires between regs and multiplier
+    logic signed [15:0] mult_out_raw; //full multiplication result
+    logic signed [9:0] mult_out_trunc;
+    logic signed [9:0] adder_input, adder_output, psum_spad_input; // result of multiplexor. chooses either result of MAC or the psum from above PE to go to adder
+
+    //counter reg and wires
+    logic [1:0] counter; //Tells which regs to use in scratchpad
+    logic [1:0] next_counter; // 1 + index
+    logic acc_psum;
+
+    //state reg and wire
+    logic next_calculating;
+    logic calculating;
+
+
+    always_comb begin
+        //============= Time to accumulate psum? ===============
+        acc_psum = (counter == 2'd3);
+
+        //============= Next State ==================
+        if ((!calculating && start_conv) || (calculating && !acc_psum)) next_calculating = '1;
+        else next_calculating = '0;
+
+        //============= Next Counter =================
+        next_counter = calculating ? counter + 1 : '0;
+
+        //============= Multiplication ===============
+        mult_out_raw = filter_spad[counter] * ifmap_spad[counter];
+        mult_out_trunc = mult_out_raw[15:6]; //truncate to 10 bits
+
+        //============= Accumulation ================
+        adder_input = acc_psum ? psum_i : mult_out_trunc;
+        adder_output = adder_input + psum_spad;
+        psum_spad_input = (calculating && !acc_psum) ? adder_output : '0;
+
+        //============= Set Output =================
+        psum_o = psum_buffer;
+    end
+
+    always_ff @(posedge clk_i, negedge rstn_i) begin
+        if (!rstn_i) begin
+            //============ set all the registers to 0 =========
+            counter <= '0;
+            for (int i = 0; i < 3; i++) begin
+                filter_spad[i] <= '0;
+                ifmap_spad[i] <= '0;
+            end
+            psum_spad <= '0;
+            psum_buffer <= '0;
+            calculating <= '0;
+            psum_valid_o <= '0;
+
+        end else begin
+            //==========   update state ===========
+            calculating <= next_calculating;
+
+            //==========  update counter  =============
+            counter <= next_counter;
+
+            //==========  update filter scratchpad  =============
+            if (read_new_filter_val) begin
+                for (int i = 0; i < 2; i++) begin
+                    filter_spad[i] <= filter_spad[i+1];
+                end
+                filter_spad[2] <= filter_i;
+            end
+
+            //==========  update ifmap scratchpad  =============
+            if (read_new_ifmap_val) begin
+                for (int i = 0; i < 2; i++) begin
+                    ifmap_spad[i] <= ifmap_spad[i+1];
+                end
+                ifmap_spad[2] <= ifmap_i;
+            end
+
+            //========= update psum buffer ==========
+            if (acc_psum) psum_buffer <= adder_output;
+
+            //========= update psum scratchpad ======
+            psum_spad <= psum_spad_input;
+
+            //============= valid bit ===================
+            psum_valid_o <= acc_psum;
+        end
+    end
+
+endmodule
\ No newline at end of file
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/src/python/canny.py b/VLSI24/submitted_notebooks/SJSystolicArray/src/python/canny.py
new file mode 100644
index 00000000..49c43ccd
--- /dev/null
+++ b/VLSI24/submitted_notebooks/SJSystolicArray/src/python/canny.py
@@ -0,0 +1,220 @@
+'''
+Reference:
+https://towardsdatascience.com/implement-canny-edge-detection-from-scratch-with-pytorch-a1cccfa58bed
+'''
+import numpy as np
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms 
+import cv2
+
+def get_gaussian_kernel(k=3, mu=0, sigma=1, normalize=True):
+    # compute 1 dimension gaussian
+    gaussian_1D = np.linspace(-1, 1, k)
+    # compute a grid distance from center
+    x, y = np.meshgrid(gaussian_1D, gaussian_1D)
+    distance = (x ** 2 + y ** 2) ** 0.5
+
+    # compute the 2 dimension gaussian
+    gaussian_2D = np.exp(-(distance - mu) ** 2 / (2 * sigma ** 2))
+    gaussian_2D = gaussian_2D / (2 * np.pi *sigma **2)
+
+    # normalize part (mathematically)
+    if normalize:
+        gaussian_2D = gaussian_2D / np.sum(gaussian_2D)
+    return gaussian_2D
+
+def get_sobel_kernel(k=3):
+    # get range
+    range = np.linspace(-(k // 2), k // 2, k)
+    # compute a grid the numerator and the axis-distances
+    x, y = np.meshgrid(range, range)
+    sobel_2D_numerator = x
+    sobel_2D_denominator = (x ** 2 + y ** 2)
+    sobel_2D_denominator[:, k // 2] = 1  # avoid division by zero
+    sobel_2D = sobel_2D_numerator / sobel_2D_denominator
+    return sobel_2D
+
+
+def get_thin_kernels(start=0, end=360, step=45):
+        k_thin = 3  # actual size of the directional kernel
+        # increase for a while to avoid interpolation when rotating
+        k_increased = k_thin + 2
+
+        # get 0° angle directional kernel
+        thin_kernel_0 = np.zeros((k_increased, k_increased))
+        thin_kernel_0[k_increased // 2, k_increased // 2] = 1
+        thin_kernel_0[k_increased // 2, k_increased // 2 + 1:] = -1
+
+        # rotate the 0° angle directional kernel to get the other ones
+        thin_kernels = []
+        for angle in range(start, end, step):
+            (h, w) = thin_kernel_0.shape
+            # get the center to not rotate around the (0, 0) coord point
+            center = (w // 2, h // 2)
+            # apply rotation
+            rotation_matrix = cv2.getRotationMatrix2D(center, angle, 1)
+            kernel_angle_increased = cv2.warpAffine(thin_kernel_0, rotation_matrix, (w, h), cv2.INTER_NEAREST)
+
+            # get the k=3 kerne
+            kernel_angle = kernel_angle_increased[1:-1, 1:-1]
+            is_diag = (abs(kernel_angle) == 1)      # because of the interpolation
+            kernel_angle = kernel_angle * is_diag   # because of the interpolation
+            thin_kernels.append(kernel_angle)
+        return thin_kernels
+
+
+def write_to_pt_file(data, filename, print_data=False):
+    torch.save(data, filename)
+    if print_data:
+        print(data) 
+
+
+class CannyFilter(nn.Module):
+    def __init__(self,
+                 k_gaussian=3,
+                 mu=0,
+                 sigma=1,
+                 k_sobel=3,
+                 use_cuda=False):
+        super(CannyFilter, self).__init__()
+        # device
+        self.device = 'cuda' if use_cuda else 'cpu'
+
+        # sobel
+        sobel_2D = get_sobel_kernel(k_sobel)
+        self.sobel_filter_x = nn.Conv2d(in_channels=1,
+                                        out_channels=1,
+                                        kernel_size=k_sobel,
+                                        padding=k_sobel // 2,
+                                        bias=False)
+        self.sobel_filter_y = nn.Conv2d(in_channels=1,
+                                        out_channels=1,
+                                        kernel_size=k_sobel,
+                                        padding=k_sobel // 2,
+                                        bias=False)
+        with torch.no_grad(): 
+            self.sobel_filter_x.weight.copy_(
+            torch.from_numpy(sobel_2D).unsqueeze(0).unsqueeze(0).float())
+        with torch.no_grad(): 
+            self.sobel_filter_y.weight.copy_(
+            torch.from_numpy(sobel_2D.T).unsqueeze(0).unsqueeze(0).float())
+
+
+        # thin
+        thin_kernels = get_thin_kernels()
+        directional_kernels = np.stack(thin_kernels)
+        self.directional_filter = nn.Conv2d(in_channels=1,
+                                            out_channels=8,
+                                            kernel_size=thin_kernels[0].shape,
+                                            padding=thin_kernels[0].shape[-1] // 2,
+                                            bias=False)
+        with torch.no_grad(): 
+            self.directional_filter.weight.copy_(
+            torch.from_numpy(directional_kernels).unsqueeze(1).float())
+
+        # hysteresis
+        hysteresis = np.ones((3, 3)) + 0.25
+        self.hysteresis = nn.Conv2d(in_channels=1,
+                                    out_channels=1,
+                                    kernel_size=3,
+                                    padding=1,
+                                    bias=False)
+        with torch.no_grad(): 
+            self.hysteresis.weight.copy_(
+            torch.from_numpy(hysteresis).unsqueeze(0).unsqueeze(0).float())
+
+
+    def forward(self, img, low_threshold=None, high_threshold=None, hysteresis=False, 
+                use_sa=False, grad_x_sa=0, grad_y_sa=0):
+        # set the setps tensors
+        B, C, H, W = img.shape
+        grad_x = torch.zeros((B, 1, H, W)).to(self.device)
+        grad_y = torch.zeros((B, 1, H, W)).to(self.device)
+        grad_magnitude = torch.zeros((B, 1, H, W)).to(self.device)
+        grad_orientation = torch.zeros((B, 1, H, W)).to(self.device)
+
+        # sobel
+        if use_sa: # caculate the grads with Systolic Array 
+            grad_x = grad_x_sa
+            grad_y = grad_y_sa
+        else: # calculate the grads with Python
+            for c in range(C):
+                soble_result_x = self.sobel_filter_x(img[:, c:c+1])
+                soble_result_y = self.sobel_filter_y(img[:, c:c+1])
+                grad_x = grad_x + soble_result_x
+                grad_y = grad_y + soble_result_y
+                write_to_pt_file(img[:, c:c+1], f'img_{c}.pt')
+                write_to_pt_file(soble_result_x, f'soble_result_x_{c}.pt')
+                write_to_pt_file(soble_result_y, f'soble_result_y_{c}.pt')
+            write_to_pt_file(self.sobel_filter_x.weight, f'soble_filter_x_weight.pt')
+            write_to_pt_file(self.sobel_filter_y.weight, f'soble_filter_y_weight.pt')
+
+        # thick edges
+        grad_x, grad_y = grad_x / C, grad_y / C
+        grad_magnitude = (grad_x ** 2 + grad_y ** 2) ** 0.5
+        grad_orientation = torch.atan(grad_y / grad_x)
+        grad_orientation = grad_orientation * (360 / np.pi) + 180 # convert to degree
+        grad_orientation = torch.round(grad_orientation / 45) * 45  # keep a split by 45
+
+        # thin edges
+        directional = self.directional_filter(grad_magnitude)
+        # get indices of positive and negative directions
+        positive_idx = (grad_orientation / 45) % 8
+        negative_idx = ((grad_orientation / 45) + 4) % 8
+        thin_edges = grad_magnitude.clone()
+        # non maximum suppression direction by direction
+        for pos_i in range(4):
+            neg_i = pos_i + 4
+            # get the oriented grad for the angle
+            is_oriented_i = (positive_idx == pos_i) * 1
+            is_oriented_i = is_oriented_i + (positive_idx == neg_i) * 1
+            pos_directional = directional[:, pos_i]
+            neg_directional = directional[:, neg_i]
+            selected_direction = torch.stack([pos_directional, neg_directional])
+            # get the local maximum pixels for the angle
+            is_max = selected_direction.min(dim=0)[0] > 0.0
+            is_max = torch.unsqueeze(is_max, dim=1)
+            # apply non maximum suppression
+            to_remove = (is_max == 0) * 1 * (is_oriented_i) > 0
+            thin_edges[to_remove] = 0.0
+
+        # thresholds
+        if low_threshold is not None:
+            low = thin_edges > low_threshold
+            if high_threshold is not None:
+                high = thin_edges > high_threshold
+                # get black/gray/white only
+                thin_edges = low * 0.5 + high * 0.5
+                if hysteresis:
+                    # get weaks and check if they are high or not
+                    weak = (thin_edges == 0.5) * 1
+                    weak_is_high = (self.hysteresis(thin_edges) > 1) * weak
+                    thin_edges = high * 1 + weak_is_high * 1
+            else:
+                thin_edges = low * 1
+        return grad_x, grad_y, grad_magnitude, grad_orientation, thin_edges
+    
+
+def main():
+    # Load the input image 
+    image = cv2.imread('rubiks_cube.jpg') 
+    image = cv2.resize(image, (256, 256))  # original 256*256
+    
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+
+    # Convert the image to Torch tensor 
+    img_tensor = torch.from_numpy(image)  #  transform(image)
+    img_tensor = img_tensor.permute(2, 0, 1).unsqueeze(0)
+
+    # Run inference
+    model = CannyFilter()
+    grad_x, grad_y, grad_magnitude, grad_orientation, thin_edges = model(img_tensor.float())
+
+    # Save image results
+    cv2.imwrite('edge_rubiks_cube.jpg', grad_magnitude[0].permute(1, 2, 0).detach().numpy())
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/src/python/full_flow.py b/VLSI24/submitted_notebooks/SJSystolicArray/src/python/full_flow.py
new file mode 100644
index 00000000..ff48b884
--- /dev/null
+++ b/VLSI24/submitted_notebooks/SJSystolicArray/src/python/full_flow.py
@@ -0,0 +1,126 @@
+import torch
+import torch.nn.functional as F
+import cv2
+from canny import CannyFilter
+from seq_generator import (gen_load_seq_idx, gen_load_seq, binary, fp32_to_fxps86binary, 
+                           fp32_to_fxps86, add_result_seq, gen_load_result_seq)
+
+import os
+import sys
+
+if len(sys.argv) != 2:
+    print("Usage: python3 full_flow.py <filename>\n filename is either \"rubikscube\" or \"userinput\"")
+    sys.exit(1)
+filenamearg = sys.argv[1].strip()
+if filenamearg == "rubikscube":
+    name = 'rubiks_cube'
+elif filenamearg == "userinput":
+    name = 'uploadedimage'
+else:
+  print("Usage: python3 full_flow.py <filename>\n filename is either \"rubikscube\" or \"userinput\"")
+filename = name + '.jpg'
+edge_filename = 'edge_' + name + '.jpg'
+edge_sa_filename = 'edge_' + name + '_sa.jpg'
+
+
+filter_size = 3
+pad = filter_size // 2
+image_size = 256
+psum_size = int(image_size - 2*((filter_size-1)/2) + 2*pad)
+
+
+# Read image, resize and convert to grayscale
+image = cv2.imread(filename) 
+image = cv2.resize(image, (image_size, image_size))  # original 256*256
+gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+  
+# Convert the image to Torch tensor 
+img_tensor = torch.from_numpy(gray_image).unsqueeze(2)  #  transform(image)
+img_tensor = img_tensor.permute(2, 0, 1).unsqueeze(0)
+
+# Run inference
+model = CannyFilter()
+grad_x, grad_y, grad_magnitude, grad_orientation, thin_edges = model(img_tensor.float())
+
+# Save image results
+cv2.imwrite(edge_filename, grad_magnitude[0].permute(1, 2, 0).detach().numpy())
+
+# Generate load sequence for Systolic Array
+ifmap = torch.load('img_0.pt').squeeze()//2
+ifmap = F.pad(ifmap, (pad, pad, pad, pad), "constant", 0)
+psum = torch.zeros((psum_size, psum_size), dtype=torch.int8)
+load_seq_idx = gen_load_seq_idx(image_size+2, filter_size)
+load_seq_idx = add_result_seq(load_seq_idx)
+
+# Sequence for convolving image and sobel_filter_x to get grad_x
+filter = torch.load('soble_filter_x_weight.pt').squeeze()
+filter = fp32_to_fxps86binary(filter.squeeze())
+result_x = torch.load('soble_result_x_0.pt').squeeze()//2
+result_x = torch.clamp(result_x, min=-127, max=127)
+load_seq_x = gen_load_result_seq(ifmap, filter, psum, result_x, load_seq_idx)
+f = open("seq_x.txt", "w")
+f.write("255,214,0\n")
+for seq in torch.tensor(load_seq_x):
+    print_seq = ','.join([str(x) for x in seq.to(dtype=torch.uint8).tolist()])
+    f.write(f'{print_seq}\n')
+f.close()
+
+# Sequence for convolving image and sobel_filter_y to get grad_y
+filter = torch.load('soble_filter_y_weight.pt').squeeze()
+filter = fp32_to_fxps86binary(filter.squeeze())
+result_y = torch.load('soble_result_y_0.pt').squeeze()//2
+result_y = torch.clamp(result_y, min=-127, max=127)
+load_seq_y = gen_load_result_seq(ifmap, filter, psum, result_y, load_seq_idx)
+f = open("seq_y.txt", "w")
+f.write("255,214,0\n")
+for seq in torch.tensor(load_seq_y):
+    print_seq = ','.join([str(x) for x in seq.to(dtype=torch.uint8).tolist()])
+    f.write(f'{print_seq}\n')
+f.close()
+
+os.system("cp seq_x.txt /content/convInput.txt")
+os.system("/content/obj_dir/Vtop > /content/SystolicArray/src/python/seq_x_SA.txt")
+
+# Get the Systolic Array result
+result_x_seq_sa = []
+with open("seq_x_SA.txt", "r") as filestream:
+    filestream.readline()
+    for line in filestream:
+        line = line.strip()
+        if line:
+            elems = line.split(",")
+            result_x_seq_sa += [[int(elems[0]), int(elems[1]), int(elems[2])]]
+result_x_seq_sa = torch.tensor(result_x_seq_sa)
+result_x_sa = torch.zeros(result_x.shape, dtype=torch.int8)
+for seq, ele in zip(load_seq_idx, result_x_seq_sa):
+    if seq[2][0] != -1:
+        result_x_sa[seq[2][1], seq[2][2]] = ele[2]
+
+os.system("cp seq_y.txt /content/convInput.txt")
+os.system("/content/obj_dir/Vtop > /content/SystolicArray/src/python/seq_y_SA.txt")
+#os.system("rm /content/convInput.txt")
+
+result_y_seq_sa = []
+with open("seq_y_SA.txt", "r") as filestream:
+    filestream.readline()
+    for line in filestream:
+        line = line.strip()
+        if line:
+            elems = line.split(",")
+            result_y_seq_sa += [[int(elems[0]), int(elems[1]), int(elems[2])]]
+result_y_seq_sa = torch.tensor(result_y_seq_sa)
+result_y_sa = torch.zeros(result_y.shape, dtype=torch.int8)
+for seq, ele in zip(load_seq_idx, result_y_seq_sa):
+    if seq[2][0] != -1:
+        result_y_sa[seq[2][1], seq[2][2]] = ele[2]
+
+# Verify Systolic Array result
+compare = result_x_sa.eq(result_x)
+# print(f'Systolic Array Result Correct: {torch.all(compare)}')
+
+# Plot Systolic Array result
+grad_x, grad_y, grad_magnitude, grad_orientation, thin_edges = model(img_tensor.float(),
+                                                                     use_sa=True,
+                                                                     grad_x_sa=result_x_sa.unsqueeze(0).unsqueeze(0)*2,
+                                                                     grad_y_sa=result_y_sa.unsqueeze(0).unsqueeze(0)*2)
+cv2.imwrite(edge_sa_filename, grad_magnitude[0].permute(1, 2, 0).detach().numpy())
\ No newline at end of file
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/src/python/rubiks_cube.jpg b/VLSI24/submitted_notebooks/SJSystolicArray/src/python/rubiks_cube.jpg
new file mode 100644
index 00000000..052a789f
Binary files /dev/null and b/VLSI24/submitted_notebooks/SJSystolicArray/src/python/rubiks_cube.jpg differ
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/src/python/seq_generator.py b/VLSI24/submitted_notebooks/SJSystolicArray/src/python/seq_generator.py
new file mode 100644
index 00000000..cc3023db
--- /dev/null
+++ b/VLSI24/submitted_notebooks/SJSystolicArray/src/python/seq_generator.py
@@ -0,0 +1,231 @@
+
+import torch
+import argparse
+import numpy as np
+from fxpmath import Fxp
+
+INIT, LOAD, RELOAD, RSLT = 0, 1, 2, 3
+IFMP, FILT, PSUM = 0, 1, 2
+IN1, IN2 = 0, 1
+NUM_PE = 3
+
+def get_int8_matrix(m, n):
+    return torch.randint(-127, 127, (m, n), dtype=torch.int8)
+
+def get_rand01_matrix(m, n):
+    return torch.rand(m, n)
+
+def binary(x, reverse=False, bits=8):
+    if reverse: # for readability
+        mask = 2**torch.arange(bits-1,-1,-1).to(x.device, x.dtype)
+    else:    
+        mask = 2**torch.arange(bits).to(x.device, x.dtype)
+    return x.unsqueeze(-1).bitwise_and(mask).ne(0).byte()
+
+
+def fp32_to_fxps86(matrix):
+    return Fxp(matrix.detach().numpy(), dtype='fxp-s8/6') # 8bit: 1b-sign, 1b-int, 6b-frac
+
+
+def fxps86_to_binary(matrix):
+    matrix = [[np.packbits(list(map(int, ele))) for ele in row] for row in matrix.bin()]
+    return torch.tensor(np.array(matrix)).squeeze()
+
+
+def fp32_to_fxps86binary(matrix):
+    return fxps86_to_binary(fp32_to_fxps86(matrix))
+
+
+def ceildiv(a, b):
+    return int(-(a // -b))
+
+
+def gen_load_seq_idx(ifmap_size, filter_size):
+    # data_idx = [matrix, row, col]
+    load_seq = []
+
+    edge = int((filter_size - 1)/2)
+    output_size = ifmap_size - edge*2
+    num_row_iter = ceildiv(output_size, NUM_PE)
+    row_coverage = NUM_PE+edge*2 
+
+    state = INIT
+    for iter in range(num_row_iter+1):
+        row_offset = iter*NUM_PE  # 0, 3, 5 ...
+        for ifmp_col in range(ifmap_size):  # 0, 1 ..., 27
+            for row in range(row_coverage):  # 0, 1, 2, 3, 4
+                target_row = row_offset + row
+                in1_idx = [IFMP, target_row, ifmp_col]
+                if state == INIT:
+                    if row < NUM_PE:  # 0, 1, 2, 3
+                        in2_idx = [FILT, target_row, ifmp_col]
+                    elif row == row_coverage-1:  # 4
+                        load_seq[-1][IN2] = [IFMP, target_row, ifmp_col]
+                        if ifmp_col == (filter_size-1): 
+                            state = LOAD # enter load state sequence
+                            in1_idx, in2_idx = [-1,-1,-1], [-1,-1,-1]
+                            load_seq += [[in1_idx, in2_idx]]
+                        continue
+                    load_seq += [[in1_idx, in2_idx]]
+                elif state == LOAD:
+                    if row < row_coverage-1:
+                        in1_idx = [IFMP, target_row, ifmp_col]
+                        in2_idx = [-1,-1,-1]
+                    else:
+                        in1_idx = [-1,-1,-1]
+                        in2_idx = [IFMP, target_row, ifmp_col]
+                    if row < NUM_PE: # PSUM load handling
+                        if not (target_row >= output_size):
+                            if row == 0:
+                                load_seq[-1][IN1] = [PSUM, target_row, ifmp_col-3]
+                            else:                
+                                load_seq[-1][IN2] = [PSUM, target_row, ifmp_col-3]
+                    if (ifmp_col == (ifmap_size-1)) and (row == (row_coverage-1)) :
+                        state = RELOAD
+                    if target_row >= ifmap_size:
+                        in1_idx, in2_idx = [-1,-1,-1], [-1,-1,-1]
+                        load_seq += [[in1_idx, in2_idx]]
+                        continue
+                    load_seq += [[in1_idx, in2_idx]]
+                elif state == RELOAD:
+                    if row < NUM_PE and ifmp_col==0: # PSUM load handling
+                        if not (target_row-filter_size >= output_size):
+                            if row == 0:
+                                load_seq[-1][IN1] = [PSUM, target_row-filter_size, output_size-1]
+                            else:                
+                                load_seq[-1][IN2] = [PSUM, target_row-filter_size, output_size-1]
+                    if row == row_coverage-1:  # 4
+                        if not (target_row >= ifmap_size):
+                            load_seq[-1][IN2] = [IFMP, target_row, ifmp_col]
+                        if ifmp_col == (filter_size-1): 
+                            state = LOAD # enter load state sequence
+                            in1_idx, in2_idx = [-1,-1,-1], [-1,-1,-1]
+                            load_seq += [[in1_idx, in2_idx]]
+                        continue
+                    if target_row >= ifmap_size:
+                        in1_idx, in2_idx = [-1,-1,-1], [-1,-1,-1]
+                        load_seq += [[in1_idx, in2_idx]]
+                        continue
+                    in2_idx = [-1,-1,-1]
+                    load_seq += [[in1_idx, in2_idx]]
+    return load_seq
+
+
+def add_result_seq(load_seq):
+    for idx, seq in enumerate(load_seq):
+        if len(seq)==3:
+            in1, in2, in3 = seq
+        else:
+            in1, in2 = seq
+            load_seq[idx] += [[-1,-1,-1]]
+        if in1[0]==PSUM:
+            load_seq[idx+3] += [[RSLT, in1[1], in1[2]]]
+        elif in2[0]==PSUM:
+            load_seq[idx+3] += [[RSLT, in2[1], in2[2]]]
+        
+    return load_seq
+
+
+def gen_load_seq(ifmap, filter, psum, load_seq_idx):
+    load_seq = []
+    in_matrix = [ifmap, filter, psum]
+
+    for seq in load_seq_idx:
+        if seq[0][0] == -1:
+            in1 = 0
+        else:
+            in1 = in_matrix[seq[0][0]][seq[0][1]][seq[0][2]]
+        if seq[1][0] == -1:
+            in2 = 0
+        else:
+            in2 = in_matrix[seq[1][0]][seq[1][1]][seq[1][2]]
+        load_seq += [[in1, in2]]
+    
+    return load_seq
+
+
+def gen_load_result_seq(ifmap, filter, psum, result, load_seq_idx):
+    load_seq = []
+    in_matrix = [ifmap, filter, psum, result]
+
+    for seq in load_seq_idx:
+        if seq[0][0] == -1:
+            in1 = 0
+        else:
+            in1 = in_matrix[seq[0][0]][seq[0][1]][seq[0][2]]
+        if seq[1][0] == -1:
+            in2 = 0
+        else:
+            in2 = in_matrix[seq[1][0]][seq[1][1]][seq[1][2]]
+        if seq[2][0] == -1:
+            in3 = 0
+        else:
+            in3 = in_matrix[seq[2][0]][seq[2][1]][seq[2][2]]
+        load_seq += [[in1, in2, in3]]
+    
+    return load_seq
+
+
+def main():
+    parser = argparse.ArgumentParser(description='PyTorch INT8 Conv Example')
+    parser.add_argument('--m', type=int, default=6,
+                        help='ifmap m x m (default: 6)')
+    parser.add_argument('--n', type=int, default=3,
+                        help='filter n x n (default: 3)')
+    
+    parser.add_argument('--no-binary', action='store_true', default=False,
+                        help='print in binary 2s complement')
+    parser.add_argument('--no-cuda', action='store_true', default=False,
+                        help='disables CUDA training')
+    parser.add_argument('--seed', type=int, default=1,
+                        help='random seed (default: 1)')
+    args = parser.parse_args()
+    torch.manual_seed(args.seed)
+    
+    use_cuda = not args.no_cuda and torch.cuda.is_available()
+    device = torch.device("cuda") if use_cuda else torch.device("cpu")
+
+    filter_fp32 = get_rand01_matrix(2,3)
+    filter_fxp = fp32_to_fxps86(filter_fp32)
+    filter_fxpbin = fxps86_to_binary(filter_fxp)
+    print(filter_fp32)
+    print(filter_fxp)
+    print(filter_fxpbin)
+
+    load_seq_idx =gen_load_seq_idx(6, 3)
+    # load_seq_idx = (torch.tensor(load_seq_idx) + 1).tolist()
+    for seq_idx in load_seq_idx:
+        print(seq_idx)
+
+    ifmap = get_int8_matrix(args.m, args.m) 
+    filter = get_int8_matrix(args.n, args.n)
+    result = torch.nn.functional.conv2d(torch.unsqueeze(torch.unsqueeze(ifmap,0),0).type(torch.int32), 
+                                        torch.unsqueeze(torch.unsqueeze(filter,0),0).type(torch.int32))
+    result = torch.squeeze(result)
+
+    psum = torch.zeros((4, 4), dtype=torch.int8)
+    load_seq = gen_load_seq(ifmap, filter, psum, load_seq_idx)
+    print("========================")
+    for seq in torch.tensor(load_seq):
+        print(seq.tolist())
+    
+    print("========================")
+    for seq in binary(torch.tensor(load_seq)):
+        print(seq.tolist())
+    
+    print("\n- ifmap - INT8 ---------------")
+    print(ifmap)
+    print("\n- filter - INT8 ---------------")
+    print(filter)
+    print("\n- Conv result - INT32 ----------")
+    print(result)
+    if not args.no_binary:
+        print("\n- ifmap - 2's ----------------")
+        print(binary(ifmap, reverse=True))
+        print("\n- filter - 2's ----------------")
+        print(binary(filter, reverse=True))
+        print("\n- result - 2's -----------")
+        print(binary(result, reverse=True, bits=32))
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/src/tb_top.cpp b/VLSI24/submitted_notebooks/SJSystolicArray/src/tb_top.cpp
new file mode 100644
index 00000000..57182b10
--- /dev/null
+++ b/VLSI24/submitted_notebooks/SJSystolicArray/src/tb_top.cpp
@@ -0,0 +1,123 @@
+#include <stdlib.h>
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <vector>
+#include <verilated.h>
+#include <verilated_vcd_c.h>
+#include "Vtop.h"
+
+VerilatedVcdC*      trace = NULL;       // Waveform Generation
+static Vtop*        top;                // DUT
+vluint64_t          sim_time = 0;       // Simultation time
+const int           TESTCASE_SIZE = 3;  // Test cases per line
+
+// Function to evaluate the DUT and dump waveforms
+void eval_and_dump_wave() {
+
+	top->eval();                // Evaluate the DUT
+	trace->dump(sim_time++);    // Dump waveforms to VCD file and increment simulation time
+}
+
+// Function to execute a single clock cycle
+void single_cycle() {
+
+    top->clk = 0;               // Set clock low
+    eval_and_dump_wave();       // Evaluate and dump waveforms
+    top->clk = 1;               // Set clock high
+    eval_and_dump_wave();       // Evaluate and dump waveforms
+}
+
+// Function to reset the DUT
+void reset(int n) {
+
+    top->nRST = 0;              // Assert reset
+    while(n-->0)                // Loop for specified number of cycles
+        single_cycle();
+    top->nRST = 1;              // Deassert reset
+}
+
+// Function to initialize simulation
+void sim_init() {
+
+	trace       = new VerilatedVcdC; 
+	top         = new Vtop;
+	top->trace(trace,0);        // Enable tracing and set start time
+	trace->open("dump.vcd");    // Open VCD file for writing waveform
+
+    top->readA = 0;             // Initialize readA signal
+    top->readB = 0;             // Initialize readB signal
+    reset(2);                   // Reset the DUT for 2 cycles
+}
+
+// Function to finalize simulation and clean up
+int sim_exit() {
+
+	eval_and_dump_wave();
+	top->final();               // Finalize DUT
+	trace->close();             // Close VCD file
+	delete top;                 // Delete DUT instance
+
+    return EXIT_SUCCESS;
+}
+
+// Function to read in test case to a vector
+void readNumbers(const std::string& filename, std::vector<int>& numbers) {
+    
+    // Open test case file
+    std::ifstream file(filename);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open file: " << filename << std::endl;
+        return;
+    }
+
+    // Read test case file line by line, extract tokens separated by ','
+    std::string line;
+    while (std::getline(file, line)) {
+        std::istringstream iss(line);
+        std::string token;
+        while (std::getline(iss, token, ',')) {
+            numbers.push_back(std::stoi(token));
+        }
+    }
+
+    // Close test case file
+    file.close();
+}
+
+// Test main
+int main(int argc, char** argv) {
+    
+    // Initialize test
+    Verilated::commandArgs(argc, argv);
+    Verilated::traceEverOn(true);
+    sim_init();
+
+    // Read in test cases
+    std::vector<int> test_cases;
+    readNumbers("/content/convInput.txt", test_cases);
+    int cycle = ceil(test_cases.size() / TESTCASE_SIZE);
+
+    std::ofstream dumpfile;
+    //dumpfile.open("resultdump.txt");
+
+    // Loop through test cases
+    for (int i = 0; i < cycle; i++) {
+        uint8_t a = test_cases[i * TESTCASE_SIZE]     & 0xFF;
+        uint8_t b = test_cases[i * TESTCASE_SIZE + 1] & 0xFF;
+        uint8_t w = test_cases[i * TESTCASE_SIZE + 2] & 0xFF;
+        
+        // Assign signals
+        top->readA = a;
+        top->readB = b;
+
+        std::cout << "0,0," << +top->write << std::endl;
+
+        single_cycle();
+    }
+
+    //dumpfile.close();
+
+    return sim_exit();
+}
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/src/top.sv b/VLSI24/submitted_notebooks/SJSystolicArray/src/top.sv
new file mode 100644
index 00000000..68ba2563
--- /dev/null
+++ b/VLSI24/submitted_notebooks/SJSystolicArray/src/top.sv
@@ -0,0 +1,208 @@
+module top(
+    input logic clk,
+    input logic nRST,
+    input logic [7:0] readA,
+    input logic [7:0] readB,
+    output logic [7:0] write
+);
+
+    logic [4:0] PERead;
+    logic [4:0] PEStart;
+    logic [2:0] filtRead;
+
+    logic [2:0] PENewOuput;
+
+    topLevelControl U1(
+        .clk(clk),
+        .nRST(nRST),
+        .readA(readA),
+        .readB(readB),
+        .PERead(PERead),
+        .PEStart(PEStart),
+        .filtRead(filtRead)
+    );
+
+    //PE Group 0
+    //PE 0,0
+    logic [9:0] psum_o00;
+
+    PE U2(
+        .clk_i(clk), 
+        .rstn_i(nRST),
+        .psum_i({{3{readA[7]}}, readA[6:0]}),
+        .filter_i(readB), 
+        .ifmap_i(readA), 
+        .read_new_filter_val(filtRead[0]),
+        .read_new_ifmap_val(PERead[0]),
+        .start_conv(PEStart[0]),
+        .psum_o(psum_o00), 
+        .psum_valid_o()
+    );
+
+    //PE Group 1
+    //PE 1,0
+
+    logic [9:0] psum_o10;
+
+    PE U3(
+        .clk_i(clk), 
+        .rstn_i(nRST),
+        .psum_i(psum_o00),
+        .filter_i(readB), 
+        .ifmap_i(readA), 
+        .read_new_filter_val(filtRead[1]),
+        .read_new_ifmap_val(PERead[1]),
+        .start_conv(PEStart[1]),
+        .psum_o(psum_o10), 
+        .psum_valid_o()
+    );
+
+    //PE 0,1
+    logic [9:0] psum_o01;
+
+    PE U4(
+        .clk_i(clk), 
+        .rstn_i(nRST),
+        .psum_i({{3{readB[7]}}, readB[6:0]}),
+        .filter_i(readB), 
+        .ifmap_i(readA), 
+        .read_new_filter_val(filtRead[0]),
+        .read_new_ifmap_val(PERead[1]),
+        .start_conv(PEStart[1]),
+        .psum_o(psum_o01), 
+        .psum_valid_o()
+    );
+
+    //PE Group 2
+    //PE 2,0
+    logic [9:0] psum_o20;
+
+    PE U5(
+        .clk_i(clk), 
+        .rstn_i(nRST),
+        .psum_i(psum_o10),
+        .filter_i(readB), 
+        .ifmap_i(readA), 
+        .read_new_filter_val(filtRead[2]),
+        .read_new_ifmap_val(PERead[2]),
+        .start_conv(PEStart[2]),
+        .psum_o(psum_o20), 
+        .psum_valid_o(PENewOuput[2])
+    );
+
+    //PE 1,1
+    logic [9:0] psum_o11;
+
+    PE U6(
+        .clk_i(clk), 
+        .rstn_i(nRST),
+        .psum_i(psum_o01),
+        .filter_i(readB), 
+        .ifmap_i(readA), 
+        .read_new_filter_val(filtRead[1]),
+        .read_new_ifmap_val(PERead[2]),
+        .start_conv(PEStart[2]),
+        .psum_o(psum_o11), 
+        .psum_valid_o()
+    );
+
+    //PE 0,2
+    logic [9:0] psum_o02;
+
+    PE U7(
+        .clk_i(clk), 
+        .rstn_i(nRST),
+        .psum_i({{3{readB[7]}}, readB[6:0]}),
+        .filter_i(readB), 
+        .ifmap_i(readA), 
+        .read_new_filter_val(filtRead[0]),
+        .read_new_ifmap_val(PERead[2]),
+        .start_conv(PEStart[2]),
+        .psum_o(psum_o02), 
+        .psum_valid_o()
+    );
+
+    //PE Group 3
+    //PE 2,1
+    logic [9:0] psum_o21;
+
+    PE U8(
+        .clk_i(clk), 
+        .rstn_i(nRST),
+        .psum_i(psum_o11),
+        .filter_i(readB), 
+        .ifmap_i(readA), 
+        .read_new_filter_val(filtRead[2]),
+        .read_new_ifmap_val(PERead[3]),
+        .start_conv(PEStart[3]),
+        .psum_o(psum_o21), 
+        .psum_valid_o(PENewOuput[1])
+    );
+
+    //PE 1,2
+    logic [9:0] psum_o12;
+
+    PE U9(
+        .clk_i(clk), 
+        .rstn_i(nRST),
+        .psum_i(psum_o02),
+        .filter_i(readB), 
+        .ifmap_i(readA), 
+        .read_new_filter_val(filtRead[1]),
+        .read_new_ifmap_val(PERead[3]),
+        .start_conv(PEStart[3]),
+        .psum_o(psum_o12), 
+        .psum_valid_o()
+    );
+
+    //PE Group 4
+    //PE 2,2
+    logic [9:0] psum_o22;
+
+    PE U10(
+        .clk_i(clk), 
+        .rstn_i(nRST),
+        .psum_i(psum_o12),
+        .filter_i(readB), 
+        .ifmap_i(readB), 
+        .read_new_filter_val(filtRead[2]),
+        .read_new_ifmap_val(PERead[4]),
+        .start_conv(PEStart[4]),
+        .psum_o(psum_o22), 
+        .psum_valid_o(PENewOuput[0])
+    );
+
+    logic[9:0] writeIntermediate;
+    logic overflowPos;
+    logic overflowNeg;
+
+    always_comb begin //select which PE is routed to output
+        casez({PENewOuput})
+            3'b1??: begin
+                writeIntermediate = psum_o20;
+            end
+            3'b01?: begin
+                writeIntermediate = psum_o21;
+            end
+            3'b001: begin
+                writeIntermediate = psum_o22;
+            end
+            default: begin
+                writeIntermediate = '0;
+            end
+        endcase
+
+        write = {writeIntermediate[9], writeIntermediate[6:0]}; //cap output to +/-127 by detecting overflows and writing max value to output in case of overflow
+        
+        overflowPos = !writeIntermediate[9] & (writeIntermediate[8] | writeIntermediate[7]);
+        overflowNeg = writeIntermediate[9] & (!writeIntermediate[8] | !writeIntermediate[7]);
+
+        if(overflowPos) begin
+            write[6:0] = '1;
+        end
+        if(overflowNeg) begin
+            write[6:0] = '0;
+        end
+    end
+
+endmodule
\ No newline at end of file
diff --git a/VLSI24/submitted_notebooks/SJSystolicArray/src/topLevelControl.sv b/VLSI24/submitted_notebooks/SJSystolicArray/src/topLevelControl.sv
new file mode 100644
index 00000000..f83376cf
--- /dev/null
+++ b/VLSI24/submitted_notebooks/SJSystolicArray/src/topLevelControl.sv
@@ -0,0 +1,144 @@
+module topLevelControl (
+    input logic clk,
+    input logic nRST,
+    input logic [7:0] readA,
+    input logic [7:0] readB,
+    output logic [4:0] PERead,
+    output logic [4:0] PEStart,
+    output logic [2:0] filtRead
+);
+
+typedef enum logic [1:0] {
+    idle,
+    loadInit,
+    loadSingle,
+    reload
+} state_t;
+
+state_t state, nextState;
+
+logic [4:0] PEReadNaive;
+
+logic [2:0] countPE, nextCountPE;
+logic [7:0] countRow, nextCountRow;
+logic [6:0] countTile, nextCountTile;
+
+logic [7:0] rowLen, nextRowLen;
+logic [6:0] colTiles, nextColTiles;
+
+always_ff @(posedge clk, negedge nRST) begin
+    if(nRST == '0) begin
+        state <= idle;
+        countPE <= '0;
+        countRow <= '0;
+        countTile <= '0;
+        rowLen <= '0;
+        colTiles <= '0;
+    end
+    else begin
+        state <= nextState;
+        countPE <= nextCountPE;
+        countRow <= nextCountRow;
+        countTile <= nextCountTile;
+        rowLen <= nextRowLen;
+        colTiles <= nextColTiles;
+    end
+end
+
+always_comb begin
+    nextState = state;
+    nextCountPE = countPE;
+    nextCountRow = countRow;
+    nextCountTile = countTile;
+
+    nextRowLen = rowLen;
+    nextColTiles = colTiles;
+
+    PEReadNaive = '0;
+
+    PERead = '0;
+    PEStart = '0;
+    filtRead = '0;
+
+    case(countPE)
+        3'd1: PEReadNaive[0] = 1'b1;
+        3'd2: PEReadNaive[1] = 1'b1;
+        3'd3: PEReadNaive[2] = 1'b1;
+        3'd4: PEReadNaive[3] = 1'b1;
+        3'd5: PEReadNaive[4] = 1'b1;
+        default:PEReadNaive = '0;
+    endcase
+
+    case(state)
+        idle: begin
+            nextCountPE = '0;
+            nextCountRow = '0;
+            nextCountTile = '0;
+            if(readA[7]) begin
+                nextRowLen = {readA[6:0], readB[7]};
+                nextColTiles = readB[6:0];
+                nextCountPE = 3'd1;
+                nextState = loadInit;
+            end
+        end
+        loadInit: begin
+            PERead = {PEReadNaive[3], PEReadNaive[3:0]};
+            filtRead = PEReadNaive[2:0];
+            nextCountPE = countPE + 3'd1;
+            if(countPE == 3'd4) begin
+                nextCountPE = 3'd1;
+                nextCountRow = countRow + 8'd1;
+            end
+            if(countRow == 8'd2) begin
+                PEStart = PEReadNaive;
+            end
+            if(countRow == 8'd3) begin
+                nextCountPE = 3'd1;
+                PEStart[4] = 1'b1;
+                filtRead = '0;
+                PERead = '0;
+                nextState = loadSingle;
+                nextCountRow = 8'd1;
+            end
+        end
+        loadSingle: begin
+            PEStart = PEReadNaive;
+            PERead = PEReadNaive;
+            nextCountPE = countPE + 3'd1;
+            if(countPE == 3'd5) begin
+                nextCountPE = 3'd1;
+                nextCountRow = countRow + 8'd1;
+                if(countRow == rowLen) begin
+                    nextState = reload;
+                    nextCountTile = countTile + 7'd1;
+                    nextCountRow = '0;
+                end
+            end
+        end
+        reload: begin
+            PERead = {PEReadNaive[3], PEReadNaive[3:0]};
+            nextCountPE = countPE + 3'd1;
+            if(countPE == 3'd4) begin
+                nextCountPE = 3'd1;
+                nextCountRow = countRow + 8'd1;
+            end
+            if(countRow == 8'd2) begin
+                PEStart = PEReadNaive;
+            end
+            if(countRow == 8'd3) begin
+                nextCountPE = 3'd1;
+                PEStart[4] = 1'b1;
+                filtRead = '0;
+                PERead = '0;
+                nextState = loadSingle;
+                nextCountRow = 8'd1;
+            end
+            if(countTile == colTiles) begin
+                nextState = idle;
+                PERead = '0;
+            end
+        end
+    endcase
+end
+    
+endmodule
\ No newline at end of file