     if ((serial_rx_buffer[0] >= startingMacroMetadataIndex) && (serial_rx_buffer[11] >= startingMacroMetadataIndex)) {
       if ((serial_rx_buffer[0] < endingMacroMetadataIndex) && (serial_rx_buffer[11] < endingMacroMetadataIndex)) {
         if (serial_rx_buffer[0] == serial_rx_buffer[11]) {
-          //Serial.print("Received loop metadata 1 info at index ");
-          //Serial.println(serial_rx_buffer[0]);
           // Stop the current loop when we receive a new macro
           macroIndex = 0;
           currentMacroIndexRunning = 0;

        }
      }
      if (currentMacroIndexRunning < macroInputsToRun) {
        //Serial.print("A BEFORE currentMacroIndexRunning = ");
        //Serial.println(currentMacroIndexRunning);
        if (howManyInnerLoopsMacroHas <= macroMetadataIndex) {
          // Do stuff normally
          Serial.println("This macro does not have inner loops OR we reached the end of inner loops");
          currentMacroIndexRunning++;
        }
        if (howManyInnerLoopsMacroHas > macroMetadataIndex) {
          // This is where inner loop logic goes
          Serial.println("This macro has inner loops");
          if (inner_loop_metadata[macroMetadataIndex][1] > 0 && inner_loop_metadata[macroMetadataIndex][3] > 0) {
            // Do something
            Serial.println("This inner loop metadata is valid");
            Serial.print("A currentMacroIndexRunning  = ");
            Serial.println(currentMacroIndexRunning);
            if (inner_loop_metadata[macroMetadataIndex][3] > 0 && inner_loop_metadata[macroMetadataIndex][4] <= inner_loop_metadata[macroMetadataIndex][3]) {
              Serial.println("TEST");
              if (inner_loop_metadata[macroMetadataIndex][2] < inner_loop_metadata[macroMetadataIndex][6]) {
                // Current input index is lower than starting index, fix this
                // Write inner loop metadata back to PC here
                Serial.println("Current input index for current inner loop is below what it is supposed to be, fix that!");
                Serial.print("B currentMacroIndexRunning  = ");
                Serial.println(currentMacroIndexRunning);
                inner_loop_metadata[macroMetadataIndex][2] = inner_loop_metadata[macroMetadataIndex][6];
                currentMacroIndexRunning = inner_loop_metadata[macroMetadataIndex][6];
                Serial.print("C currentMacroIndexRunning  = ");
                Serial.println(currentMacroIndexRunning);
                // Write inner loop metadata back to PC here
              }
              if (inner_loop_metadata[macroMetadataIndex][2] >= inner_loop_metadata[macroMetadataIndex][6] && currentMacroIndexRunning <= inner_loop_metadata[macroMetadataIndex][7]) {
                // Current input index is valid
                // Write inner loop metadata back to PC here
                Serial.println("Current input index for current inner loop is in the valid range!");
                Serial.print("D currentMacroIndexRunning  = ");
                Serial.println(currentMacroIndexRunning);
                currentMacroIndexRunning++;
                inner_loop_metadata[macroMetadataIndex][2]++;
                Serial.print("E currentMacroIndexRunning  = ");
                Serial.println(currentMacroIndexRunning);
                // Write inner loop metadata back to PC here
              }
              if (inner_loop_metadata[macroMetadataIndex][2] > inner_loop_metadata[macroMetadataIndex][7]) {
                // Inner loop ended?
                // Write inner loop metadata back to PC here
                Serial.println("Inner loop ended");
                Serial.print("F currentMacroIndexRunning  = ");
                Serial.println(currentMacroIndexRunning);
                currentMacroIndexRunning = inner_loop_metadata[macroMetadataIndex][6];
                inner_loop_metadata[macroMetadataIndex][2] = inner_loop_metadata[macroMetadataIndex][6];
                inner_loop_metadata[macroMetadataIndex][4]++;
                Serial.print("inner_loop_metadata[macroMetadataIndex][4] = ");
                Serial.println(inner_loop_metadata[macroMetadataIndex][4]);
                Serial.print("G currentMacroIndexRunning  = ");
                Serial.println(currentMacroIndexRunning);
                // Write inner loop metadata back to PC here
              }
            }
            if (inner_loop_metadata[macroMetadataIndex][3] > 0 && inner_loop_metadata[macroMetadataIndex][4] > inner_loop_metadata[macroMetadataIndex][3]) {
              Serial.println("Broke out from inner loop?");
              Serial.print("H currentMacroIndexRunning  = ");
              Serial.println(currentMacroIndexRunning);
              //currentMacroIndexRunning = inner_loop_metadata[macroMetadataIndex][7] + 1;
              macroMetadataIndex++;
              Serial.print("I currentMacroIndexRunning  = ");
              Serial.println(currentMacroIndexRunning);
            }
            Serial.print("J currentMacroIndexRunning  = ");
            Serial.println(currentMacroIndexRunning);
          }
          if (inner_loop_metadata[macroMetadataIndex][1] <= 0 || inner_loop_metadata[macroMetadataIndex][3] <= 0) {
            // Ignore this inner loop, it is not valid
            Serial.println("This inner loop metadata is not valid");
            Serial.print("K currentMacroIndexRunning  = ");
            Serial.println(currentMacroIndexRunning);
            currentMacroIndexRunning++;
            Serial.print("L currentMacroIndexRunning  = ");
            Serial.println(currentMacroIndexRunning);
          }
        }
        //Serial.print("B AFTER currentMacroIndexRunning = ");
        //Serial.println(currentMacroIndexRunning);
      }
      if (loopMacro > 0) {
        if (currentMacroIndexRunning >= macroInputsToRun) {
          //Serial.print("C BEFORE currentMacroIndexRunning = ");
          //Serial.println(currentMacroIndexRunning);
          currentMacroIndexRunning = 0;
          //Serial.print("D AFTER currentMacroIndexRunning = ");
          //Serial.println(currentMacroIndexRunning);
          /*
            if (timesToLoop <= 0) {
            //
            }
          */
          // The block below resets all inner loop metadata counters
          if (howManyInnerLoopsMacroHas > 0) {
            Serial.println("TEST ABC");
            macroMetadataIndex = 0;
            // Check if the first inner loop metadata is valid, if it is, use that, if not, disregard and don't do anything
            if (inner_loop_metadata[0][1] > 0 && inner_loop_metadata[0][3] > 0) {
              // Accept inner loop metadata if first inner loop metadata is valid
              Serial.println("TEST DEF");
              macroMetadataIndex = 0;
              for (uint8_t macroMetadataIndexInner = 0; macroMetadataIndexInner < howManyInnerLoopsMacroHas; macroMetadataIndexInner++) {
                Serial.print("BEFORE macroMetadataIndexInner = ");
                Serial.println(macroMetadataIndexInner);
                inner_loop_metadata[macroMetadataIndexInner][2] = 0; // Reset current input index for inner loop
                inner_loop_metadata[macroMetadataIndexInner][4] = 0; // Reset current repeat counter for inner loop
                Serial.print("AFTER macroMetadataIndexInner = ");
                Serial.println(macroMetadataIndexInner);
              }
            }
            if (inner_loop_metadata[0][1] <= 0 || inner_loop_metadata[0][3] <= 0) {
              // Clear all inner loop metadata if first inner loop metadata is invalid
              macroMetadataIndex = 0;
              howManyInnerLoopsMacroHas = 0;
              Serial.println("TEST GHI");
              for (uint8_t macroMetadataIndexInner = 0; macroMetadataIndexInner < macroMetadataSize; macroMetadataIndexInner++) {
                Serial.print("BEFORE macroMetadataIndexInner = ");
                Serial.println(macroMetadataIndexInner);
                inner_loop_metadata[macroMetadataIndexInner][0] = 0;
                inner_loop_metadata[macroMetadataIndexInner][1] = 0;
                inner_loop_metadata[macroMetadataIndexInner][2] = 0;
                inner_loop_metadata[macroMetadataIndexInner][3] = 0;
                inner_loop_metadata[macroMetadataIndexInner][4] = 0;
                inner_loop_metadata[macroMetadataIndexInner][5] = 0;
                inner_loop_metadata[macroMetadataIndexInner][6] = 0;
                inner_loop_metadata[macroMetadataIndexInner][7] = 0;
                inner_loop_metadata[macroMetadataIndexInner][8] = 0;
                inner_loop_metadata[macroMetadataIndexInner][9] = 0;
                inner_loop_metadata[macroMetadataIndexInner][10] = 0;
                inner_loop_metadata[macroMetadataIndexInner][11] = 0;
                Serial.print("AFTER macroMetadataIndexInner = ");
                Serial.println(macroMetadataIndexInner);
              }
            }
          }
          if (timesToLoop > 0 && loopCounter <= timesToLoop) {
            // Sending this block for redundancy sake, will comment this block if something goes wrong (it shouldn't)
            Serial.print("M BEFORE loopCounter = ");
            Serial.println(loopCounter);
            Serial.write(endingMacroIndex);
            Serial.write(macroInputsToRun);
            Serial.write(loopMacro);

            inner_loop_metadata[macroMetadataIndex][2] = 0; // Current input index
            inner_loop_metadata[macroMetadataIndex][3] = 0; // Times to repeat (number of times this inner loop should be executed, before going to the next inner loop, if any)
            inner_loop_metadata[macroMetadataIndex][4] = 0; // Repeat counter (number of times this inner loop was executed)
            inner_loop_metadata[macroMetadataIndex][5] = 0; // Where is the next inner loop's first input (index 0 input for the next inner loop, aka the index for the input in the macro_buffer array) (Continue normally if value is 0, or do nothing if there are no more inputs to be executed) // Current unused, apply logic to this // Is this really needed? (maybe as a failsafe?) (I will not use this variable for anything because I'm scared it'll break things during an actual run)
            inner_loop_metadata[macroMetadataIndex][6] = 0; // Where to start (index of the starting input) (Inclusive)
            inner_loop_metadata[macroMetadataIndex][7] = 0; // Where to end (index of the ending input) (Inclusive)
            inner_loop_metadata[macroMetadataIndex][8] = 0; // How many inner loops that should be executed after this (if <=0, don't execute inner loops any inner loops after this, and move on as normal, if there are normal inputs to be exeucuted, execute those, if there's nothing else to do, go back to the beginning of the larger loop, if > 0, execute n inner loops after this) // Currently unused, apply logic to this // Is this really needed? (maybe as a failsafe?) (I will not use this variable for anything because I'm scared it'll break things during an actual run)
            inner_loop_metadata[macroMetadataIndex][9] = 0; // Unused?
            inner_loop_metadata[macroMetadataIndex][10] = 0; // Unused?
            inner_loop_metadata[macroMetadataIndex][11] = 0; // Postamble
          */
          for (uint8_t macroInputMetadataIndex = 0; macroInputMetadataIndex < sizeof(serial_rx_buffer); macroInputMetadataIndex++) {
            inner_loop_metadata[macroMetadataIndex][macroInputMetadataIndex] = serial_rx_buffer[macroInputMetadataIndex];
          }
        }
      }
    }
  }
  runMacro();
