diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs
index 73fc928e9..a74d71d8a 100644
--- a/pallets/subtensor/src/coinbase/run_coinbase.rs
+++ b/pallets/subtensor/src/coinbase/run_coinbase.rs
@@ -49,14 +49,13 @@ impl<T: Config> Pallet<T> {
         let total_moving_prices = acc_total_moving_prices;
         log::debug!("total_moving_prices: {total_moving_prices:?}");
 
-        // --- 3. Get subnet terms (tao_in, alpha_in, and alpha_out)
-        // Computation is described in detail in the dtao whitepaper.
-        let mut tao_in: BTreeMap<NetUid, U96F32> = BTreeMap::new();
-        let mut alpha_in: BTreeMap<NetUid, U96F32> = BTreeMap::new();
+        let mut tao_in_total: TaoCurrency = 0.into();
         let mut alpha_out: BTreeMap<NetUid, U96F32> = BTreeMap::new();
         let mut is_subsidized: BTreeMap<NetUid, bool> = BTreeMap::new();
         // Only calculate for subnets that we are emitting to.
         for netuid_i in subnets_to_emit_to.iter() {
+            // --- 3. Get subnet terms (tao_in, alpha_in, and alpha_out)
+            // Computation is described in detail in the dtao whitepaper.
             // Get subnet price.
             let price_i = T::SwapInterface::current_alpha_price((*netuid_i).into());
             log::debug!("price_i: {price_i:?}");
@@ -118,50 +117,44 @@ impl<T: Config> Pallet<T> {
                 alpha_in_i = asfloat!(0.0);
                 alpha_out_i = asfloat!(0.0);
             }
-            // Insert values into maps
-            tao_in.insert(*netuid_i, tao_in_i);
-            alpha_in.insert(*netuid_i, alpha_in_i);
+            // Insert value into map
             alpha_out.insert(*netuid_i, alpha_out_i);
-        }
-        log::debug!("tao_in: {tao_in:?}");
-        log::debug!("alpha_in: {alpha_in:?}");
-        log::debug!("alpha_out: {alpha_out:?}");
 
-        // --- 4. Injection.
-        // Actually perform the injection of alpha_in, alpha_out and tao_in into the subnet pool.
-        // This operation changes the pool liquidity each block.
-        for netuid_i in subnets_to_emit_to.iter() {
+            // --- 4. Injection.
+            // Actually perform the injection of alpha_in, alpha_out and tao_in into the subnet pool.
+            // This operation changes the pool liquidity each block.
             // Inject Alpha in.
-            let alpha_in_i =
-                AlphaCurrency::from(tou64!(*alpha_in.get(netuid_i).unwrap_or(&asfloat!(0))));
-            SubnetAlphaInEmission::<T>::insert(*netuid_i, alpha_in_i);
+            let alpha_in_curr = AlphaCurrency::from(tou64!(alpha_in_i));
+            SubnetAlphaInEmission::<T>::insert(*netuid_i, alpha_in_curr);
             SubnetAlphaIn::<T>::mutate(*netuid_i, |total| {
-                *total = total.saturating_add(alpha_in_i);
+                *total = total.saturating_add(alpha_in_curr);
             });
             // Injection Alpha out.
-            let alpha_out_i =
-                AlphaCurrency::from(tou64!(*alpha_out.get(netuid_i).unwrap_or(&asfloat!(0))));
-            SubnetAlphaOutEmission::<T>::insert(*netuid_i, alpha_out_i);
+            let alpha_out_curr = AlphaCurrency::from(tou64!(alpha_out_i));
+            SubnetAlphaOutEmission::<T>::insert(*netuid_i, alpha_out_curr);
             SubnetAlphaOut::<T>::mutate(*netuid_i, |total| {
-                *total = total.saturating_add(alpha_out_i);
+                *total = total.saturating_add(alpha_out_curr);
             });
             // Inject TAO in.
-            let tao_in_i: TaoCurrency =
-                tou64!(*tao_in.get(netuid_i).unwrap_or(&asfloat!(0))).into();
-            SubnetTaoInEmission::<T>::insert(*netuid_i, TaoCurrency::from(tao_in_i));
+            let tao_in_curr: TaoCurrency = tou64!(tao_in_i).into();
+            SubnetTaoInEmission::<T>::insert(*netuid_i, TaoCurrency::from(tao_in_curr));
             SubnetTAO::<T>::mutate(*netuid_i, |total| {
-                *total = total.saturating_add(tao_in_i.into());
-            });
-            TotalStake::<T>::mutate(|total| {
-                *total = total.saturating_add(tao_in_i.into());
-            });
-            TotalIssuance::<T>::mutate(|total| {
-                *total = total.saturating_add(tao_in_i.into());
+                *total = total.saturating_add(tao_in_curr.into());
             });
+            tao_in_total = tao_in_total.saturating_add(tao_in_curr);
             // Adjust protocol liquidity based on new reserves
-            T::SwapInterface::adjust_protocol_liquidity(*netuid_i, tao_in_i, alpha_in_i);
+            T::SwapInterface::adjust_protocol_liquidity(*netuid_i, tao_in_curr, alpha_in_curr);
         }
 
+        TotalStake::<T>::mutate(|total| {
+            *total = total.saturating_add(tao_in_total.into());
+        });
+        TotalIssuance::<T>::mutate(|total| {
+            *total = total.saturating_add(tao_in_total.into());
+        });
+
+        log::debug!("alpha_out: {alpha_out:?}");
+
         // --- 5. Compute owner cuts and remove them from alpha_out remaining.
         // Remove owner cuts here so that we can properly seperate root dividends in the next step.
         // Owner cuts are accumulated and then fed to the drain at the end of this func.