diff --git a/src/artigen/artigen.d.ts b/src/artigen/artigen.d.ts
index 4a77b2d..1e0a454 100644
--- a/src/artigen/artigen.d.ts
+++ b/src/artigen/artigen.d.ts
@@ -23,6 +23,7 @@ export interface SolvedRoll {
   line1: string;
   line2: string;
   line3: string;
+  footer: string;
   counts: CountDetails;
   rollDistributions: RollDistributionMap;
 }
diff --git a/src/artigen/artigen.ts b/src/artigen/artigen.ts
index 7883b19..99b7c96 100644
--- a/src/artigen/artigen.ts
+++ b/src/artigen/artigen.ts
@@ -5,12 +5,12 @@ import { tokenizeCmd } from 'artigen/cmdTokenizer.ts';
 
 import { Modifiers } from 'artigen/dice/getModifiers.ts';
 
-import { loopCountCheck } from 'artigen/managers/loopManager.ts';
+import { getLoopCount, loopCountCheck } from 'artigen/managers/loopManager.ts';
 import { QueuedRoll } from 'artigen/managers/manager.d.ts';
 
 import { reduceCountDetails } from 'artigen/utils/counter.ts';
 import { cmdSplitRegex, escapeCharacters, withYVarsDash } from 'artigen/utils/escape.ts';
-import { loggingEnabled } from 'artigen/utils/logFlag.ts';
+import { loggingEnabled, loopLoggingEnabled } from 'artigen/utils/logFlag.ts';
 import { assertPrePostBalance } from 'artigen/utils/parenBalance.ts';
 import { reduceRollDistMaps } from 'artigen/utils/rollDist.ts';
 import { compareTotalRolls, compareTotalRollsReverse, sortYVars } from 'artigen/utils/sortFuncs.ts';
@@ -26,6 +26,7 @@ export const runCmd = (rollRequest: QueuedRoll): SolvedRoll => {
     line1: '',
     line2: '',
     line3: '',
+    footer: '',
     counts: {
       total: 0,
       successful: 0,
@@ -120,7 +121,7 @@ export const runCmd = (rollRequest: QueuedRoll): SolvedRoll => {
     const line2Space = rollRequest.modifiers.noSpaces ? '' : ' ';
     // Fill out all of the details and results now
     tempReturnData.forEach((e, i) => {
-      loopCountCheck();
+      loopCountCheck('artigen.ts - tempReturnData');
 
       loggingEnabled && log(LT.LOG, `Parsing roll ${rollRequest.rollCmd} | Making return text ${JSON.stringify(e)}`);
       let preFormat = '';
@@ -178,5 +179,7 @@ export const runCmd = (rollRequest: QueuedRoll): SolvedRoll => {
     [returnMsg.errorCode, returnMsg.errorMsg] = translateError(solverError);
   }
 
+  if (loopLoggingEnabled) returnMsg.footer = `Loop Count: ${getLoopCount()}`;
+
   return returnMsg;
 };
diff --git a/src/artigen/cmdTokenizer.ts b/src/artigen/cmdTokenizer.ts
index f285f44..e0fef18 100644
--- a/src/artigen/cmdTokenizer.ts
+++ b/src/artigen/cmdTokenizer.ts
@@ -32,7 +32,7 @@ export const tokenizeCmd = (
 
   // Wrapped commands still exist, unwrap them
   while (cmd.includes(config.prefix)) {
-    loopCountCheck();
+    loopCountCheck('cmdTokenizer.ts - while cmd includes prefix');
 
     const openIdx = cmd.indexOf(config.prefix);
     const closeIdx = getMatchingPostfixIdx(cmd, openIdx);
@@ -49,7 +49,7 @@ export const tokenizeCmd = (
 
     const simulatedData: ReturnData[] = [];
     for (let i = 0; i < simulatedLoopCount; i++) {
-      loopCountCheck();
+      loopCountCheck('cmdTokenizer.ts - simulate nominal loop');
 
       loggingEnabled && log(LT.LOG, `In simLoop:${i} "${currentCmd}" of ${JSON.stringify(cmd)}`);
 
@@ -78,7 +78,7 @@ export const tokenizeCmd = (
         loggingEnabled && log(LT.LOG, `ConfirmCrit on ${JSON.stringify(currentCmd)}`);
         let done = false;
         while (!done) {
-          loopCountCheck();
+          loopCountCheck('cmdTokenizer.ts - confirming crit');
 
           // Keep running the same roll again until its not successful
           const [ccTempData, ccTempCounts, ccTempDists] = tokenizeCmd(
@@ -194,7 +194,7 @@ export const tokenizeCmd = (
     const tempInitConf = data.initConfig.split(internalGrpWrapRegex).filter((x) => x);
     loggingEnabled && log(LT.LOG, `Split solved math into tempInitConf ${JSON.stringify(tempInitConf)}`);
     while (tempInitConf.includes(openInternalGrp)) {
-      loopCountCheck();
+      loopCountCheck('cmdTokenizer.ts - handling internal group result merging');
 
       const openIdx = tempInitConf.indexOf(openInternalGrp);
       const closeIdx = getMatchingInternalGrpIdx(tempInitConf, openIdx);
@@ -214,7 +214,7 @@ export const tokenizeCmd = (
       .filter((x) => x);
     loggingEnabled && log(LT.LOG, `Split tempInitConfig into initConf ${JSON.stringify(initConf)}`);
     while (initConf.includes(openInternal)) {
-      loopCountCheck();
+      loopCountCheck('cmdTokenizer.ts - handling internal nested roll result merging');
 
       const openIdx = initConf.indexOf(openInternal);
       const closeIdx = getMatchingInternalIdx(initConf, openIdx);
diff --git a/src/artigen/dice/executeRoll.ts b/src/artigen/dice/executeRoll.ts
index e436e44..690cc26 100644
--- a/src/artigen/dice/executeRoll.ts
+++ b/src/artigen/dice/executeRoll.ts
@@ -80,7 +80,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
   for (let i = 0; i < rollConf.dieCount; i++) {
     loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | Initial rolling ${i} of ${JSON.stringify(rollConf)}`);
     // If loopCount gets too high, stop trying to calculate infinity
-    loopCountCheck();
+    loopCountCheck('executeRoll.ts - handling initial rolling');
 
     // Copy the template to fill out for this iteration
     const rolling = getTemplateRoll();
@@ -104,7 +104,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
     for (let i = 0; i < rollSet.length; i++) {
       loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | Handling rerolling and exploding ${JSON.stringify(rollSet[i])}`);
       // If loopCount gets too high, stop trying to calculate infinity
-      loopCountCheck();
+      loopCountCheck('executeRoll.ts - handling rerolling and exploding');
 
       // This big boolean statement first checks if reroll is on, if the roll is within the reroll range, and finally if ro is ON, make sure we haven't already rerolled the roll
       if (rollConf.reroll.on && rollConf.reroll.nums.includes(rollSet[i].roll) && (!rollConf.reroll.once || !rollSet[i ? i - 1 : i].rerolled)) {
@@ -117,7 +117,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
         if (modifiers.maxRoll && !minMaxOverride) {
           // If maximizeRoll is on and we've entered the reroll code, dieSize is not allowed, determine the next best option and always return that
           mmMaxLoop: for (let m = rollConf.dieSize - 1; m > 0; m--) {
-            loopCountCheck();
+            loopCountCheck('executeRoll.ts - maximizeRoll');
 
             if (!rollConf.reroll.nums.includes(m)) {
               minMaxOverride = m;
@@ -127,7 +127,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
         } else if (modifiers.minRoll && !minMaxOverride) {
           // If minimizeRoll is on and we've entered the reroll code, 1 is not allowed, determine the next best option and always return that
           mmMinLoop: for (let m = rollConf.dPercent.on ? 1 : 2; m <= rollConf.dieSize; m++) {
-            loopCountCheck();
+            loopCountCheck('executeRoll.ts - minimizeRoll');
 
             if (!rollConf.reroll.nums.includes(m)) {
               minMaxOverride = m;
@@ -181,7 +181,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
     for (const penRoll of rollSet) {
       loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | Handling penetrating explosions ${JSON.stringify(penRoll)}`);
       // If loopCount gets too high, stop trying to calculate infinity
-      loopCountCheck();
+      loopCountCheck('executeRoll.ts - penetrating explosion');
 
       // If the die was from an explosion, decrement it by one
       if (penRoll.exploding) {
@@ -195,7 +195,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
     for (let i = 0; i < rollSet.length; i++) {
       loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | Handling compounding explosions ${JSON.stringify(rollSet[i])}`);
       // If loopCount gets too high, stop trying to calculate infinity
-      loopCountCheck();
+      loopCountCheck('executeRoll.ts - compounding explosion');
 
       // Compound the exploding rolls, including the exploding flag and
       if (rollSet[i].exploding) {
@@ -215,8 +215,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
     let rerollCount = 0;
     if (rollConf.reroll.on) {
       for (let j = 0; j < rollSet.length; j++) {
-        // If loopCount gets too high, stop trying to calculate infinity
-        loopCountCheck();
+        loopCountCheck('executeRoll.ts - count rerolls');
 
         loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | Setting originalIdx on ${JSON.stringify(rollSet[j])}`);
         rollSet[j].origIdx = j;
@@ -265,8 +264,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
     // Now its time to drop all dice needed
     let i = 0;
     while (dropCount > 0 && i < rollSet.length) {
-      // If loopCount gets too high, stop trying to calculate infinity
-      loopCountCheck();
+      loopCountCheck('executeRoll.ts - dropping/keeping');
 
       loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | Dropping dice ${dropCount} ${JSON.stringify(rollSet[i])}`);
       // Skip all rolls that were rerolled
@@ -290,7 +288,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
 
     // Drop all dice that are not a part of the max
     for (const ovaRoll of rollSet) {
-      loopCountCheck();
+      loopCountCheck('executeRoll.ts - OVA');
 
       loggingEnabled &&
         log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | checking if this roll should be dropped ${ovaRoll.roll} | to keep: ${maxRoll}`);
@@ -311,7 +309,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
     const labels = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
     let labelIdx = 0;
     const rollLabels: Array<string> = rollVals.map((count) => {
-      loopCountCheck();
+      loopCountCheck('executeRoll.ts - matching');
 
       if (labelIdx >= labels.length) {
         throw new Error(`TooManyLabels_${labels.length}`);
@@ -327,7 +325,7 @@ export const executeRoll = (rollStr: string, modifiers: RollModifiers): Executed
 
     // Apply labels
     for (const roll of rollSet) {
-      loopCountCheck();
+      loopCountCheck('executeRoll.ts - labeling matches');
 
       loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | trying to add a label to ${JSON.stringify(roll)}`);
       if (rollLabels[roll.roll - 1]) {
diff --git a/src/artigen/dice/generateFormattedRoll.ts b/src/artigen/dice/generateFormattedRoll.ts
index cb64fe8..182bc32 100644
--- a/src/artigen/dice/generateFormattedRoll.ts
+++ b/src/artigen/dice/generateFormattedRoll.ts
@@ -20,7 +20,7 @@ export const formatRoll = (executedRoll: ExecutedRoll, modifiers: RollModifiers)
   // Loop thru all parts of the roll to document everything that was done to create the total roll
   loggingEnabled && log(LT.LOG, `Formatting roll ${JSON.stringify(executedRoll)}`);
   executedRoll.rollSet.forEach((e) => {
-    loopCountCheck();
+    loopCountCheck('generateFormattedRoll.ts - formatting executed roll');
 
     loggingEnabled && log(LT.LOG, `At ${JSON.stringify(e)}`);
     let preFormat = '';
diff --git a/src/artigen/dice/getGroupConf.ts b/src/artigen/dice/getGroupConf.ts
index 710713b..b5bca05 100644
--- a/src/artigen/dice/getGroupConf.ts
+++ b/src/artigen/dice/getGroupConf.ts
@@ -14,7 +14,7 @@ export const getGroupConf = (groupStr: string, rawStr: string): GroupConf => {
 
   let biggest = parseInt(numberMatches.length ? numberMatches[0] : '1');
   for (const num of numberMatches) {
-    loopCountCheck();
+    loopCountCheck('getGroupConf.ts - finding biggest number for die size');
 
     const curNum = parseInt(num);
     loggingEnabled && log(LT.LOG, `Finding biggest number to use as die size, ${curNum} ${biggest}`);
@@ -37,7 +37,7 @@ export const getGroupConf = (groupStr: string, rawStr: string): GroupConf => {
   let maxFail: number | null = null;
 
   while (groupSplit.length) {
-    loopCountCheck();
+    loopCountCheck('getGroupConf.ts - parsing groupConf');
 
     const option = groupSplit.shift() ?? '';
     const value = parseInt(groupSplit.shift() ?? '');
diff --git a/src/artigen/dice/getRollConf.ts b/src/artigen/dice/getRollConf.ts
index a9534ec..03ceedb 100644
--- a/src/artigen/dice/getRollConf.ts
+++ b/src/artigen/dice/getRollConf.ts
@@ -126,7 +126,7 @@ export const getRollConf = (rollStr: string, customTypes: CustomDiceShapes = new
     const difficulty = parseInt(tempDifficulty.slice(0, afterDifficultyIdx) || '10');
 
     for (let i = difficulty; i <= rollConf.dieSize; i++) {
-      loopCountCheck();
+      loopCountCheck('getRollConf.ts - setting cwod difficulty');
 
       loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling cwod ${rollStr} | Parsing difficulty ${i}`);
       rollConf.success.range.push(i);
@@ -216,7 +216,7 @@ export const getRollConf = (rollStr: string, customTypes: CustomDiceShapes = new
 
     // Loop until all remaining args are parsed
     while (remains.length > 0) {
-      loopCountCheck();
+      loopCountCheck('getRollConf.ts - parsing rollConf');
 
       loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | Parsing remains ${remains}`);
       // Find the next number in the remains to be able to cut out the rule name
@@ -232,7 +232,7 @@ export const getRollConf = (rollStr: string, customTypes: CustomDiceShapes = new
       let noNumberAfter = false;
       if (!(Object.values(DiceOptions) as string[]).includes(tempSep)) {
         NumberlessDiceOptions.some((opt) => {
-          loopCountCheck();
+          loopCountCheck('getRollConf.ts - parsing numberlessDiceOptions');
           loggingEnabled && log(LT.LOG, `In NumberlessDiceOptions ${opt} ${tempSep.startsWith(opt) && tempSep !== opt}`);
           if (tempSep.startsWith(opt) && tempSep !== opt) {
             afterSepIdx = opt.length;
diff --git a/src/artigen/dice/groupHandler.ts b/src/artigen/dice/groupHandler.ts
index afc46ef..a0f9091 100644
--- a/src/artigen/dice/groupHandler.ts
+++ b/src/artigen/dice/groupHandler.ts
@@ -30,7 +30,7 @@ export const handleGroup = (
 
   // Nested groups still exist, unwrap them
   while (groupParts.includes('{')) {
-    loopCountCheck();
+    loopCountCheck('groupHandler.ts - handling nested groups');
 
     loggingEnabled && log(LT.LOG, `Handling Nested Groups | Current cmd: ${JSON.stringify(groupParts)}`);
 
@@ -72,7 +72,7 @@ export const handleGroup = (
     const groupResults: ReturnData[] = [];
 
     for (const part of commaParts) {
-      loopCountCheck();
+      loopCountCheck('groupHandler.ts - solving commaParts');
 
       loggingEnabled && log(LT.LOG, `Solving commaPart: ${part}`);
       const [tempData, tempCounts, tempDists] = tokenizeMath(part, modifiers, previousResults, prevGrpReturnData);
@@ -131,7 +131,7 @@ export const handleGroup = (
 
         let i = 0;
         while (dropCount > 0 && i < groupResults.length) {
-          loopCountCheck();
+          loopCountCheck('groupHandler.ts - handling group drop/keep');
 
           loggingEnabled && log(LT.LOG, `Handling group dropping | Dropping ${dropCount}`);
 
@@ -148,7 +148,7 @@ export const handleGroup = (
       let failCnt = 0;
       if (groupConf.success.on || groupConf.fail.on) {
         groupResults.forEach((rd, idx) => {
-          loopCountCheck();
+          loopCountCheck('groupHandler.ts - handling group success/fail');
 
           if (!resultFlags[idx].dropped) {
             if (
@@ -265,7 +265,7 @@ export const handleGroup = (
   const initConf = retData.initConfig.split(internalGrpWrapRegex).filter((x) => x);
   loggingEnabled && log(LT.LOG, `Split retData into initConf ${JSON.stringify(initConf)}`);
   while (initConf.includes(openInternalGrp)) {
-    loopCountCheck();
+    loopCountCheck('groupHandler.ts - handling merging nested groups up');
 
     const openIdx = initConf.indexOf(openInternalGrp);
     const closeIdx = getMatchingInternalGrpIdx(initConf, openIdx);
diff --git a/src/artigen/managers/artigenWorker.ts b/src/artigen/managers/artigenWorker.ts
index 2c5e2ac..2a0a551 100644
--- a/src/artigen/managers/artigenWorker.ts
+++ b/src/artigen/managers/artigenWorker.ts
@@ -1,12 +1,13 @@
 import { closeLog, initLog } from '@Log4Deno';
 
 import { runCmd } from 'artigen/artigen.ts';
+import { SolvedRoll } from 'artigen/artigen.d.ts';
 
 import { QueuedRoll } from 'artigen/managers/manager.d.ts';
 
-import { loggingEnabled } from 'artigen/utils/logFlag.ts';
+import { loggingEnabled, loopLoggingEnabled } from 'artigen/utils/logFlag.ts';
 
-loggingEnabled && initLog('logs/worker', loggingEnabled);
+(loggingEnabled || loopLoggingEnabled) && initLog('logs/worker', loggingEnabled || loopLoggingEnabled);
 
 // Extend the BigInt prototype to support JSON.stringify
 interface BigIntX extends BigInt {
@@ -23,13 +24,14 @@ self.postMessage('ready');
 // Handle the roll
 self.onmessage = async (e: MessageEvent<QueuedRoll>) => {
   const payload = e.data;
-  const returnMsg = runCmd(payload) || {
+  const returnMsg: SolvedRoll = runCmd(payload) || {
     error: true,
     errorCode: 'EmptyMessage',
     errorMsg: 'Error: Empty message',
     line1: '',
     line2: '',
     line3: '',
+    footer: '',
     counts: {
       total: 0,
       successful: 0,
@@ -37,6 +39,9 @@ self.onmessage = async (e: MessageEvent<QueuedRoll>) => {
       rerolled: 0,
       dropped: 0,
       exploded: 0,
+      success: 0,
+      fail: 0,
+      matches: new Map<string, number>(),
     },
   };
   self.postMessage(returnMsg);
diff --git a/src/artigen/managers/loopManager.ts b/src/artigen/managers/loopManager.ts
index 2510878..3fe511e 100644
--- a/src/artigen/managers/loopManager.ts
+++ b/src/artigen/managers/loopManager.ts
@@ -1,10 +1,15 @@
+import { log, LogTypes as LT } from '@Log4Deno';
+
 import config from '~config';
 
+import { loopLoggingEnabled } from 'artigen/utils/logFlag.ts';
+
 let loopCount = 0;
 
 // Will ensure if maxLoops is 10, 10 loops will be allowed, 11 will not.
-export const loopCountCheck = (): void => {
+export const loopCountCheck = (location = 'unset'): void => {
   loopCount++;
+  loopLoggingEnabled && log(LT.LOG, `Loop #${loopCount} at "${location}"`);
   if (loopCount > config.limits.maxLoops) {
     throw new Error('MaxLoopsExceeded');
   }
diff --git a/src/artigen/math/mathSolver.ts b/src/artigen/math/mathSolver.ts
index ec6009a..97d7e21 100644
--- a/src/artigen/math/mathSolver.ts
+++ b/src/artigen/math/mathSolver.ts
@@ -34,7 +34,7 @@ export const mathSolver = (conf: MathConf[], wrapDetails = false): SolvedStep =>
 
   // Evaluate all parenthesis
   while (conf.includes('(')) {
-    loopCountCheck();
+    loopCountCheck('mathSolver.ts - evaluating parens');
 
     loggingEnabled && log(LT.LOG, `Evaluating roll ${JSON.stringify(conf)} | Looking for (`);
     // Get first open parenthesis
@@ -75,7 +75,7 @@ export const mathSolver = (conf: MathConf[], wrapDetails = false): SolvedStep =>
   // Start at index 1 as there will never be implicit multiplication before the first element
   loggingEnabled && log(LT.LOG, `Checking for missing implicit multiplication ${JSON.stringify(conf)}`);
   for (let i = 1; i < conf.length; i++) {
-    loopCountCheck();
+    loopCountCheck('mathSolver.ts - checking for implicit multiplication');
 
     const prevConfAsStr = <string> conf[i - 1];
     const curConfAsStr = <string> conf[i];
@@ -94,10 +94,11 @@ export const mathSolver = (conf: MathConf[], wrapDetails = false): SolvedStep =>
     ['+', '-'],
   ];
   allCurOps.forEach((curOps) => {
+    // No loopCountCheck here since its finite/will always be 3 loops
     loggingEnabled && log(LT.LOG, `Evaluating roll ${JSON.stringify(conf)} | Evaluating ${JSON.stringify(curOps)}`);
     // Iterate thru all operators/operands in the conf
     for (let i = 0; i < conf.length; i++) {
-      loopCountCheck();
+      loopCountCheck('mathSolver.ts - evaluating roll');
 
       loggingEnabled && log(LT.LOG, `Evaluating roll ${JSON.stringify(conf)} | Evaluating ${JSON.stringify(curOps)} | Checking ${JSON.stringify(conf[i])}`);
       // Check if the current index is in the active tier of operators
diff --git a/src/artigen/math/mathTokenizer.ts b/src/artigen/math/mathTokenizer.ts
index 36aa610..c7361af 100644
--- a/src/artigen/math/mathTokenizer.ts
+++ b/src/artigen/math/mathTokenizer.ts
@@ -49,7 +49,7 @@ export const tokenizeMath = (
 
   // Evaluate all rolls into stepSolve format and all numbers into floats
   for (let i = 0; i < mathConf.length; i++) {
-    loopCountCheck();
+    loopCountCheck('mathTokenizer.ts - parsing all tokens into MathConf');
 
     loggingEnabled && log(LT.LOG, `Parsing roll ${JSON.stringify(cmd)} | Evaluating rolls into math-able items ${JSON.stringify(mathConf[i])}`);
 
@@ -272,7 +272,7 @@ export const tokenizeMath = (
 
       let i = 0;
       while (dropCount > 0 && i < allRollSets.length) {
-        loopCountCheck();
+        loopCountCheck('mathTokenizer.ts - handling group dropping');
 
         loggingEnabled && log(LT.LOG, `Handling group dropping | Dropping ${dropCount}, looking at ${JSON.stringify(allRollSets[i])}`);
 
@@ -293,7 +293,7 @@ export const tokenizeMath = (
     // Handle marking new successes/fails
     if (groupConf.success.on || groupConf.fail.on) {
       allRollSets.forEach((rs) => {
-        loopCountCheck();
+        loopCountCheck('mathTokenizer.ts - handling group success/fails');
 
         if (!rs.dropped && !rs.rerolled) {
           if (groupConf.success.on && groupConf.success.range.includes(rs.roll)) {
diff --git a/src/artigen/utils/counter.ts b/src/artigen/utils/counter.ts
index 06f3b65..920397e 100644
--- a/src/artigen/utils/counter.ts
+++ b/src/artigen/utils/counter.ts
@@ -16,7 +16,7 @@ export const rollCounter = (rollSet: RollSet[]): CountDetails => {
   };
 
   rollSet.forEach((roll) => {
-    loopCountCheck();
+    loopCountCheck('counter.ts - summing RollSet into CountDetails');
     countDetails.total++;
     if (roll.critHit) countDetails.successful++;
     if (roll.critFail) countDetails.failed++;
@@ -34,9 +34,9 @@ export const rollCounter = (rollSet: RollSet[]): CountDetails => {
 export const reduceCountDetails = (counts: CountDetails[]): CountDetails =>
   counts.reduce(
     (acc, cur) => {
-      loopCountCheck();
+      loopCountCheck('counter.ts - merging array of CountDetails down to single CountDetail');
       cur.matches.forEach((cnt, label) => {
-        loopCountCheck();
+        loopCountCheck('counter.ts - merging matches');
         acc.matches.set(label, (acc.matches.get(label) ?? 0) + cnt);
       });
       return {
diff --git a/src/artigen/utils/embeds.ts b/src/artigen/utils/embeds.ts
index ea37d74..e13e8b9 100644
--- a/src/artigen/utils/embeds.ts
+++ b/src/artigen/utils/embeds.ts
@@ -259,13 +259,17 @@ export const generateRollEmbed = (
 
   // Embed desc limit is 4096
   // Discord only formats 200 items per message
-  if (fullDesc.length < 4_000 && formattingCount <= 200) {
+  const fullSize = fullDesc.length + returnDetails.footer.length;
+  if (fullSize < 4_000 && formattingCount <= 200) {
     // Response is valid size
     return {
-      charCount: fullDesc.length,
+      charCount: fullSize,
       embed: {
         color: infoColor2,
         description: fullDesc,
+        footer: {
+          text: returnDetails.footer,
+        },
       },
       hasAttachment: false,
     };
diff --git a/src/artigen/utils/escape.ts b/src/artigen/utils/escape.ts
index cc15968..3cf1ae0 100644
--- a/src/artigen/utils/escape.ts
+++ b/src/artigen/utils/escape.ts
@@ -11,7 +11,7 @@ import { loggingEnabled } from 'artigen/utils/logFlag.ts';
 export const escapeCharacters = (str: string, esc: string): string => {
   // Loop thru each esc char one at a time
   for (const e of esc) {
-    loopCountCheck();
+    loopCountCheck('escape.ts - escaping characters');
 
     loggingEnabled && log(LT.LOG, `Escaping character ${e} | ${str}, ${esc}`);
     // Create a new regex to look for that char that needs replaced and escape it
diff --git a/src/artigen/utils/logFlag.ts b/src/artigen/utils/logFlag.ts
index 177f748..7d53553 100644
--- a/src/artigen/utils/logFlag.ts
+++ b/src/artigen/utils/logFlag.ts
@@ -1 +1,2 @@
 export const loggingEnabled = false;
+export const loopLoggingEnabled = false;
diff --git a/src/artigen/utils/parenBalance.ts b/src/artigen/utils/parenBalance.ts
index cde3cad..09673df 100644
--- a/src/artigen/utils/parenBalance.ts
+++ b/src/artigen/utils/parenBalance.ts
@@ -22,7 +22,8 @@ const checkBalance = (
 
   // Verify there are equal numbers of opening and closing parenthesis by adding 1 for opening parens and subtracting 1 for closing parens
   for (let i = openIdx; i < conf.length; i++) {
-    countLoops && loopCountCheck();
+    countLoops &&
+      loopCountCheck(`parenBalance.ts - ${getMatching ? 'Looking for matching' : 'Checking'} ${openStr}/${closeStr} ${getMatching ? '' : 'balance '}`);
     loggingEnabled &&
       log(
         LT.LOG,
diff --git a/src/artigen/utils/rangeAdder.ts b/src/artigen/utils/rangeAdder.ts
index 3d3b090..e2380d4 100644
--- a/src/artigen/utils/rangeAdder.ts
+++ b/src/artigen/utils/rangeAdder.ts
@@ -14,7 +14,7 @@ export const addToRange = (tSep: string, range: Array<number>, tNum: number) =>
 
 const internalAddMultipleToRange = (tSep: string, range: Array<number>, start: number, end: number) => {
   for (let i = start; i <= end; i++) {
-    loopCountCheck();
+    loopCountCheck(`rangeAdder.ts - ${tSep} range adder`);
     addToRange(tSep, range, i);
   }
 };
diff --git a/src/artigen/utils/rollDist.ts b/src/artigen/utils/rollDist.ts
index 92f6bfc..1a94a6c 100644
--- a/src/artigen/utils/rollDist.ts
+++ b/src/artigen/utils/rollDist.ts
@@ -10,7 +10,7 @@ export const createRollDistMap = (rollSet: RollSet[]): RollDistributionMap => {
   const rollDistMap = new Map<string, number[]>();
 
   rollSet.forEach((roll) => {
-    loopCountCheck();
+    loopCountCheck('rollDist.ts - convert RollSet into RollDist');
     const tempArr: number[] = rollDistMap.get(rollDistKey(roll.type, roll.size)) ?? new Array<number>(roll.type === 'fate' ? roll.size + 2 : roll.size).fill(0);
     tempArr[roll.type === 'fate' ? roll.roll + 1 : roll.roll - 1]++;
     rollDistMap.set(rollDistKey(roll.type, roll.size), tempArr);
@@ -22,17 +22,17 @@ export const createRollDistMap = (rollSet: RollSet[]): RollDistributionMap => {
 // Collapses an array of RollDistMaps into a single RollDistMap
 export const reduceRollDistMaps = (rollDistArr: RollDistributionMap[]): RollDistributionMap =>
   rollDistArr.reduce((acc, cur) => {
-    loopCountCheck();
+    loopCountCheck('rollDist.ts - merge array of RollDists into single RollDist');
 
     cur
       .entries()
       .toArray()
       .forEach(([key, value]) => {
-        loopCountCheck();
+        loopCountCheck('rollDist.ts - doing the merge on each item of current');
 
         const tempArr = acc.get(key) ?? new Array<number>(value.length).fill(0);
         for (let i = 0; i < tempArr.length; i++) {
-          loopCountCheck();
+          loopCountCheck('rollDist.ts - doing the merge');
           tempArr[i] += value[i];
         }
 
diff --git a/src/artigen/utils/rollValCounter.ts b/src/artigen/utils/rollValCounter.ts
index 11f6673..2eb568c 100644
--- a/src/artigen/utils/rollValCounter.ts
+++ b/src/artigen/utils/rollValCounter.ts
@@ -12,7 +12,7 @@ export const generateRollVals = (rollConf: RollConf, rollSet: RollSet[], rollStr
 
   // Count up all rolls
   for (const ovaRoll of rollSet) {
-    loopCountCheck();
+    loopCountCheck('rollValCounter.ts - counting roll vals');
 
     loggingEnabled && log(LT.LOG, `${getLoopCount()} Handling ${rollConf.type} ${rollStr} | incrementing rollVals for ${JSON.stringify(ovaRoll)}`);
     if (!ovaRoll.dropped && !ovaRoll.rerolled) {