Caching more iaea stuff

9 files changed, 463 insertions, 141 deletions

diff --git a/README.md b/README.md
index e7c2f509ee..f13e1a6d91 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ http://jenkins.usrv.de:8081/job/Tec%20Tech/
 https://jenkins.datamats.com/job/TecTech/
 
 # Runtime Dependencies?
-https://github.com/Technus/TecTech/blob/master/src/main/java/com/github/technus/tectech/TecTech.java#L26
+https://github.com/Technus/TecTech/blob/master/src/main/java/com/github/technus/tectech/TecTech.java#L30
 - Required After
 
 
diff --git a/src/main/java/com/github/technus/tectech/elementalMatter/core/cElementalDefinitionStackMap.java b/src/main/java/com/github/technus/tectech/elementalMatter/core/cElementalDefinitionStackMap.java
index c46df6c826..823dbfecdf 100644
--- a/src/main/java/com/github/technus/tectech/elementalMatter/core/cElementalDefinitionStackMap.java
+++ b/src/main/java/com/github/technus/tectech/elementalMatter/core/cElementalDefinitionStackMap.java
@@ -32,6 +32,10 @@ public final class cElementalDefinitionStackMap/*IMMUTABLE*/ extends cElementalS
         map = new TreeMap<>(in);
     }
 
+    cElementalDefinitionStackMap(cElementalMutableDefinitionStackMap unsafeMap){
+        map=unsafeMap.map;
+    }
+
     //IMMUTABLE DON'T NEED IT
     @Override
     public final cElementalDefinitionStackMap clone() {
diff --git a/src/main/java/com/github/technus/tectech/elementalMatter/core/cElementalMutableDefinitionStackMap.java b/src/main/java/com/github/technus/tectech/elementalMatter/core/cElementalMutableDefinitionStackMap.java
index a20b1c2ddb..ab1e53ac41 100644
--- a/src/main/java/com/github/technus/tectech/elementalMatter/core/cElementalMutableDefinitionStackMap.java
+++ b/src/main/java/com/github/technus/tectech/elementalMatter/core/cElementalMutableDefinitionStackMap.java
@@ -53,6 +53,9 @@ public final class cElementalMutableDefinitionStackMap extends cElementalStackMa
     public cElementalDefinitionStackMap toImmutable() {
         return new cElementalDefinitionStackMap(map);
     }
+    public cElementalDefinitionStackMap toImmutable_unsafeMightLeaveExposedElementalTree() {
+        return new cElementalDefinitionStackMap(this);
+    }
 
     @Override
     @Deprecated
diff --git a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/dAtomDefinition.java b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/dAtomDefinition.java
index 4f82a1afdb..f3042b95ac 100644
--- a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/dAtomDefinition.java
+++ b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/dAtomDefinition.java
@@ -10,7 +10,10 @@ import com.github.technus.tectech.elementalMatter.core.containers.cElementalDefi
 import com.github.technus.tectech.elementalMatter.core.interfaces.iElementalDefinition;
 import com.github.technus.tectech.elementalMatter.core.tElementalException;
 import com.github.technus.tectech.elementalMatter.core.templates.cElementalDefinition;
-import com.github.technus.tectech.elementalMatter.core.transformations.*;
+import com.github.technus.tectech.elementalMatter.core.transformations.aFluidDequantizationInfo;
+import com.github.technus.tectech.elementalMatter.core.transformations.aItemDequantizationInfo;
+import com.github.technus.tectech.elementalMatter.core.transformations.aOredictDequantizationInfo;
+import com.github.technus.tectech.elementalMatter.core.transformations.bTransformationInfo;
 import com.github.technus.tectech.elementalMatter.definitions.complex.iaea.iaeaNuclide;
 import com.github.technus.tectech.elementalMatter.definitions.primitive.eBosonDefinition;
 import com.github.technus.tectech.elementalMatter.definitions.primitive.eLeptonDefinition;
@@ -19,7 +22,6 @@ import cpw.mods.fml.common.Loader;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.OrePrefixes;
 import net.minecraft.nbt.NBTTagCompound;
-import net.minecraftforge.oredict.OreDictionary;
 
 import java.util.*;
 
@@ -46,8 +48,7 @@ public final class dAtomDefinition extends cElementalDefinition {
     private static final Map<Integer, dAtomDefinition> stableAtoms = new HashMap<>();
     private static Map<Integer, TreeMap<Float, Integer>> mostStableUnstableIsotopes = new HashMap<>();
     private static final Map<Integer, dAtomDefinition> unstableAtoms = new HashMap<>();
-    private static cElementalDefinitionStack alpha;
-
+    private static cElementalDefinitionStack alpha,deuterium,tritium,helium_3,beryllium_8,carbon_14,neon_24,silicon_34;
     private static final HashMap<dAtomDefinition,Float> lifetimeOverrides = new HashMap<>();
     public static final ArrayList<Runnable> overrides = new ArrayList<>();
 
@@ -353,24 +354,27 @@ public final class dAtomDefinition extends cElementalDefinition {
     private cElementalDecay[] getDecayArray(ArrayList<cElementalDecay> decaysList,int decayMode) {
         if (this.type == 1) {
             switch (decayMode) {
+                case -3:
+                    if(ElectronCapture(decaysList))
+                        return decaysList.toArray(new cElementalDecay[decaysList.size()]);
                 case -2:
-                    if(PbetaDecay(decaysList,1))
+                    if(PbetaDecay(decaysList))
                         return decaysList.toArray(new cElementalDecay[decaysList.size()]);
                     break;
                 case -1:
-                    if(Emmision(decaysList,1,dHadronDefinition.hadron_p1))
+                    if(Emmision(decaysList, dHadronDefinition.hadron_p1))
                         return decaysList.toArray(new cElementalDecay[decaysList.size()]);
                     break;
                 case 0:
-                    if(alphaDecay(decaysList,1))
+                    if(alphaDecay(decaysList))
                         return decaysList.toArray(new cElementalDecay[decaysList.size()]);
                     break;
                 case 1:
-                    if(Emmision(decaysList,1,dHadronDefinition.hadron_n1))
+                    if(Emmision(decaysList, dHadronDefinition.hadron_n1))
                         return decaysList.toArray(new cElementalDecay[decaysList.size()]);
                     break;
                 case 2:
-                    if(MbetaDecay(decaysList,1))
+                    if(MbetaDecay(decaysList))
                         return decaysList.toArray(new cElementalDecay[decaysList.size()]);
                     break;
                 default:
@@ -399,75 +403,359 @@ public final class dAtomDefinition extends cElementalDefinition {
     }
 
     private boolean getDecay(ArrayList<cElementalDecay> decaysList,iaeaNuclide.iaeaDecay decay){
+        cElementalMutableDefinitionStackMap withThis=elementalStacks.toMutable(),additional=new cElementalMutableDefinitionStackMap();
         switch (decay.decayName){
-            case "14C":
-                break;
-            case "24NE":
-                break;
-            case "2B+":
-                break;
-            case "2B-":
-                break;
-            case "2EC":
-                break;
-            case "2N":
-                return Emmision(decaysList,decay.chance,dHadronDefinition.hadron_n2);
-            case "2P":
-                return Emmision(decaysList,decay.chance,dHadronDefinition.hadron_p2);
-            case "34SI":
-                break;
-            case "3H":
-                break;
-            case "3HE":
-                break;
-            case "8BE":
-                break;
-            case "A": case "A?":
-                return alphaDecay(decaysList,decay.chance);
-            case "B+":
-                return PbetaDecay(decaysList,decay.chance);
-            case "B++EC": case "EC+B+":
-                break;
-            case "B+2P":
-                break;
-            case "B+A":
-                break;
-            case "B+P":
+            case "D": {
+                if (withThis.removeAllAmounts(false, deuterium.definition.getSubParticles())){
+                    withThis.putReplace(deuterium);
+                    decaysList.add(new cElementalDecay(decay.chance,withThis.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                    return true;
+                }
+            } break;
+            case "3H": {
+                if (withThis.removeAllAmounts(false, tritium.definition.getSubParticles())){
+                    withThis.putReplace(tritium);
+                    decaysList.add(new cElementalDecay(decay.chance,withThis.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                    return true;
+                }
+            } break;
+            case "3HE": {
+                if (withThis.removeAllAmounts(false, helium_3.definition.getSubParticles())){
+                    withThis.putReplace(helium_3);
+                    decaysList.add(new cElementalDecay(decay.chance,withThis.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                    return true;
+                }
+            } break;
+            case "8BE": {
+                if (withThis.removeAllAmounts(false, beryllium_8.definition.getSubParticles())){
+                    withThis.putReplace(beryllium_8);
+                    decaysList.add(new cElementalDecay(decay.chance,withThis.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                    return true;
+                }
+            } break;
+            case "14C": {
+                if (withThis.removeAllAmounts(false, carbon_14.definition.getSubParticles())){
+                    additional.putReplace(carbon_14);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "24NE": {
+                if (withThis.removeAllAmounts(false, neon_24.definition.getSubParticles())){
+                    additional.putReplace(neon_24);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "34SI": {
+                if (withThis.removeAllAmounts(false, silicon_34.definition.getSubParticles())){
+                    additional.putReplace(silicon_34);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "A": case "A?": {
+                if (withThis.removeAllAmounts(false, alpha.definition.getSubParticles())){
+                    additional.putReplace(alpha);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B+": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_p1)){
+                    withThis.putUnify(dHadronDefinition.hadron_n1);
+                    additional.putReplace(eLeptonDefinition.lepton_e_1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve1);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "2B+": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_p2)){
+                    withThis.putUnify(dHadronDefinition.hadron_n2);
+                    additional.putReplace(eLeptonDefinition.lepton_e_2);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve2);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B-": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_n1)){
+                    withThis.putUnify(dHadronDefinition.hadron_p1);
+                    additional.putReplace(eLeptonDefinition.lepton_e1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve_1);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "2B-": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_n2)){
+                    withThis.putUnify(dHadronDefinition.hadron_p2);
+                    additional.putReplace(eLeptonDefinition.lepton_e2);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve_2);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "EC": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_p1,eLeptonDefinition.lepton_e1)){
+                    withThis.putUnify(dHadronDefinition.hadron_n1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve1);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "2EC": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_p2,eLeptonDefinition.lepton_e2)){
+                    withThis.putUnify(dHadronDefinition.hadron_n2);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve2);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B++EC": case "EC+B+": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_p2,eLeptonDefinition.lepton_e1)){
+                    withThis.putUnify(dHadronDefinition.hadron_n2);
+                    additional.putReplace(eLeptonDefinition.lepton_e_1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve2);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B+A": {
+                if (withThis.removeAllAmounts(false, alpha.definition.getSubParticles()) && withThis.removeAmount(false, dHadronDefinition.hadron_p1)){
+                    withThis.putUnify(dHadronDefinition.hadron_n1);
+                    additional.putReplace(eLeptonDefinition.lepton_e_1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve1);
+                    additional.putReplace(alpha);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B+P": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_p2)){
+                    withThis.putUnify(dHadronDefinition.hadron_n1);
+                    additional.putReplace(eLeptonDefinition.lepton_e_1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve1);
+                    additional.putReplace(dHadronDefinition.hadron_p1);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B+2P": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_p3)){
+                    withThis.putUnify(dHadronDefinition.hadron_n1);
+                    additional.putReplace(eLeptonDefinition.lepton_e_1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve1);
+                    additional.putReplace(dHadronDefinition.hadron_p2);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B-A": {
+                if (withThis.removeAllAmounts(false, alpha.definition.getSubParticles()) && withThis.removeAmount(false,dHadronDefinition.hadron_n1)){
+                    withThis.putUnify(dHadronDefinition.hadron_p1);
+                    additional.putReplace(eLeptonDefinition.lepton_e1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve_1);
+                    additional.putReplace(alpha);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B-N": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_n2)){
+                    withThis.putUnify(dHadronDefinition.hadron_p1);
+                    additional.putReplace(eLeptonDefinition.lepton_e1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve_1);
+                    additional.putReplace(dHadronDefinition.hadron_n1);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B-2N": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_n3)){
+                    withThis.putUnify(dHadronDefinition.hadron_p1);
+                    additional.putReplace(eLeptonDefinition.lepton_e1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve_1);
+                    additional.putReplace(dHadronDefinition.hadron_n2);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "B-P": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_n1, dHadronDefinition.hadron_p1)){
+                    withThis.putUnify(dHadronDefinition.hadron_p1);
+                    additional.putReplace(eLeptonDefinition.lepton_e1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve_1);
+                    additional.putReplace(dHadronDefinition.hadron_p1);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "ECA": {
+                if (withThis.removeAllAmounts(false, alpha.definition.getSubParticles()) && withThis.removeAllAmounts(false, dHadronDefinition.hadron_p1,eLeptonDefinition.lepton_e1)){
+                    withThis.putUnify(dHadronDefinition.hadron_n1);
+                    additional.putReplace(eNeutrinoDefinition.lepton_Ve1);
+                    additional.putReplace(alpha);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "ECP":
                 break;
-            case "B-":
-                return MbetaDecay(decaysList,decay.chance);
-            case "B-2N":
+            case "EC2P":
                 break;
-            case "B-A":
+            case "ECP+EC2P":
                 break;
+            case "N": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_n1)){
+                    additional.putReplace(dHadronDefinition.hadron_n1);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "2N": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_n2)){
+                    additional.putReplace(dHadronDefinition.hadron_n2);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "P": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_p1)){
+                    additional.putReplace(dHadronDefinition.hadron_p1);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "2P": {
+                if (withThis.removeAllAmounts(false, dHadronDefinition.hadron_p2)){
+                    additional.putReplace(dHadronDefinition.hadron_p2);
+                    try{
+                        additional.putReplace(new dAtomDefinition(withThis.toImmutable_unsafeMightLeaveExposedElementalTree()).getStackForm(1));
+                        decaysList.add(new cElementalDecay(decay.chance,additional.toImmutable_unsafeMightLeaveExposedElementalTree()));
+                        return true;
+                    }catch (Exception e){
+                        if(DEBUG_MODE) e.printStackTrace();
+                    }
+                }
+            } break;
+            case "SF":
+                return Fission(decaysList,decay.chance,false,withThis);
             case "B-F":
                 break;
-            case "B-N":
-                break;
-            case "B-P":
-                break;
-            case "D":
-                break;
-            case "EC":
-                break;
-            case "EC2P":
-                break;
-            case "ECA":
-                break;
             case "ECF": case "ECSF": case "EC(+SF)":
                 break;
-            case "ECP":
-                break;
-            case "ECP+EC2P":
-                break;
-            case "IT+EC+B+":
-                break;
-            case "N":
-                return Emmision(decaysList,decay.chance,dHadronDefinition.hadron_n1);
-            case "P":
-                return Emmision(decaysList,decay.chance,dHadronDefinition.hadron_p1);
-            case "SF":
-                return Fission(decaysList,decay.chance,false);
             case "SF(+EC+B+)": case "SF+EC+B+":
                 break;
             case "SF+EC+B-":
@@ -475,19 +763,22 @@ public final class dAtomDefinition extends cElementalDefinition {
             case "IT": case "IT?": case "G":
                 decaysList.add(new cElementalDecay(decay.chance, this, eBosonDefinition.boson_Y__));
                 return true;
+            case "IT+EC+B+":
+                break;
             case "DEAD_END":
                 decaysList.add(deadEnd);
                 return true;
             default: throw new Error("Unsupported decay mode: " + decay.decayName + " "+ neutralCount+" "+element);
         }
+        if(DEBUG_MODE) TecTech.Logger.info("Failed to decay "+element+" "+neutralCount+" "+decay.decayName);
         return false;
     }
 
-    private boolean Emmision(ArrayList<cElementalDecay> decaysList, float probability, cElementalDefinitionStack emit) {
+    private boolean Emmision(ArrayList<cElementalDecay> decaysList, cElementalDefinitionStack emit) {
         final cElementalMutableDefinitionStackMap tree = elementalStacks.toMutable();
         if (tree.removeAmount(false, emit)) {
             try {
-                decaysList.add(new cElementalDecay(probability, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable()), 1), emit));
+                decaysList.add(new cElementalDecay((float) 1, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable_unsafeMightLeaveExposedElementalTree()), 1), emit));
                 return true;
             } catch (Exception e) {
                 if (DEBUG_MODE) e.printStackTrace();
@@ -496,11 +787,11 @@ public final class dAtomDefinition extends cElementalDefinition {
         return false;
     }
 
-    private boolean alphaDecay(ArrayList<cElementalDecay> decaysList,float probability) {
+    private boolean alphaDecay(ArrayList<cElementalDecay> decaysList) {
         final cElementalMutableDefinitionStackMap tree = elementalStacks.toMutable();
         if (tree.removeAllAmounts(false, dHadronDefinition.hadron_n2, dHadronDefinition.hadron_p2)) {
             try {
-                decaysList.add(new cElementalDecay(probability, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable()), 1), alpha));
+                decaysList.add(new cElementalDecay((float) 1, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable_unsafeMightLeaveExposedElementalTree()), 1), alpha));
                 return true;
             } catch (Exception e) {
                 if (DEBUG_MODE) e.printStackTrace();
@@ -509,12 +800,12 @@ public final class dAtomDefinition extends cElementalDefinition {
         return false;
     }
 
-    private boolean MbetaDecay(ArrayList<cElementalDecay> decaysList,float probability) {
+    private boolean MbetaDecay(ArrayList<cElementalDecay> decaysList) {
         final cElementalMutableDefinitionStackMap tree = elementalStacks.toMutable();
         if (tree.removeAmount(false, dHadronDefinition.hadron_n1)) {
             try {
                 tree.putUnify(dHadronDefinition.hadron_p1);
-                decaysList.add(new cElementalDecay(probability, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable()), 1), eLeptonDefinition.lepton_e1, eNeutrinoDefinition.lepton_Ve_1));
+                decaysList.add(new cElementalDecay((float) 1, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable_unsafeMightLeaveExposedElementalTree()), 1), eLeptonDefinition.lepton_e1, eNeutrinoDefinition.lepton_Ve_1));
                 return true;
             } catch (Exception e) {
                 if (DEBUG_MODE) e.printStackTrace();
@@ -523,12 +814,12 @@ public final class dAtomDefinition extends cElementalDefinition {
         return false;
     }
 
-    private boolean PbetaDecay(ArrayList<cElementalDecay> decaysList,float probability) {
+    private boolean PbetaDecay(ArrayList<cElementalDecay> decaysList) {
         final cElementalMutableDefinitionStackMap tree = elementalStacks.toMutable();
         if (tree.removeAmount(false, dHadronDefinition.hadron_p1)) {
             try {
                 tree.putUnify(dHadronDefinition.hadron_n1);
-                decaysList.add(new cElementalDecay(probability, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable()), 1), eLeptonDefinition.lepton_e_1, eNeutrinoDefinition.lepton_Ve1));
+                decaysList.add(new cElementalDecay((float) 1, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable_unsafeMightLeaveExposedElementalTree()), 1), eLeptonDefinition.lepton_e_1, eNeutrinoDefinition.lepton_Ve1));
                 return true;
             } catch (Exception e) {
                 if (DEBUG_MODE) e.printStackTrace();
@@ -537,12 +828,12 @@ public final class dAtomDefinition extends cElementalDefinition {
         return false;
     }
 
-    private boolean ElectronCapture(ArrayList<cElementalDecay> decaysList,float probability) {
+    private boolean ElectronCapture(ArrayList<cElementalDecay> decaysList) {
         final cElementalMutableDefinitionStackMap tree = elementalStacks.toMutable();
-        if (tree.removeAmount(false, eLeptonDefinition.lepton_e1) && tree.removeAmount(false, dHadronDefinition.hadron_p1)) {
+        if (tree.removeAllAmounts(false, dHadronDefinition.hadron_p1,eLeptonDefinition.lepton_e1)) {
             try {
                 tree.putUnify(dHadronDefinition.hadron_n1);
-                decaysList.add(new cElementalDecay(0.5f, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable()), 1), eNeutrinoDefinition.lepton_Ve1));
+                decaysList.add(new cElementalDecay((float) 1, new cElementalDefinitionStack(new dAtomDefinition(tree.toImmutable_unsafeMightLeaveExposedElementalTree()), 1), eLeptonDefinition.lepton_e_1, eNeutrinoDefinition.lepton_Ve1));
                 return true;
             } catch (Exception e) {
                 if (DEBUG_MODE) e.printStackTrace();
@@ -551,13 +842,12 @@ public final class dAtomDefinition extends cElementalDefinition {
         return false;
     }
 
-    private boolean Fission(ArrayList<cElementalDecay> decaysList,float probability,boolean spontaneousCheck) {
-        final cElementalMutableDefinitionStackMap light = elementalStacks.toMutable();
+    private boolean Fission(ArrayList<cElementalDecay> decaysList,float probability,boolean spontaneousCheck, cElementalMutableDefinitionStackMap fissile) {
         final cElementalMutableDefinitionStackMap heavy = new cElementalMutableDefinitionStackMap();
         final ArrayList<cElementalDefinitionStack> particles = new ArrayList<>(4);
         final double[] liquidDrop=liquidDropFunction(Math.abs(element)<=97);
 
-        for(cElementalDefinitionStack stack:light.values()){
+        for(cElementalDefinitionStack stack: fissile.values()){
             if(spontaneousCheck && stack.definition instanceof dHadronDefinition &&
                     (stack.amount<=80 || (stack.amount<90 && XSTR_INSTANCE.nextInt(10)<stack.amount-80)))
                 return false;
@@ -571,7 +861,7 @@ public final class dAtomDefinition extends cElementalDefinition {
                     int heavy_cnt=(int)Math.ceil(stack.amount*liquidDrop[1]);
                     while(heavy_cnt+neutrals_cnt>stack.amount)
                         heavy_cnt--;
-                    light.removeAmount(false,new cElementalDefinitionStack(stack.definition,heavy_cnt+neutrals_cnt));
+                    fissile.removeAmount(false,new cElementalDefinitionStack(stack.definition,heavy_cnt+neutrals_cnt));
                     heavy.putReplace(new cElementalDefinitionStack(stack.definition, heavy_cnt));
                 //}else{
                 //    particles.add(stack);
@@ -582,14 +872,14 @@ public final class dAtomDefinition extends cElementalDefinition {
                 if(heavy_cnt%2==1 && XSTR_INSTANCE.nextFloat()>0.05f)
                     heavy_cnt--;
                 cElementalDefinitionStack new_stack=new cElementalDefinitionStack(stack.definition, heavy_cnt);
-                light.removeAmount(false,new_stack);
+                fissile.removeAmount(false,new_stack);
                 heavy.putReplace(new_stack);
             }
         }
 
         try {
-            particles.add(new cElementalDefinitionStack(new dAtomDefinition(light.toImmutable()),1));
-            particles.add(new cElementalDefinitionStack(new dAtomDefinition(heavy.toImmutable()),1));
+            particles.add(new cElementalDefinitionStack(new dAtomDefinition(fissile.toImmutable_unsafeMightLeaveExposedElementalTree()),1));
+            particles.add(new cElementalDefinitionStack(new dAtomDefinition(heavy.toImmutable_unsafeMightLeaveExposedElementalTree()),1));
             decaysList.add(new cElementalDecay(0.5f, particles.toArray(new cElementalDefinitionStack[particles.size()])));
             return true;
         } catch (Exception e) {
@@ -711,7 +1001,7 @@ public final class dAtomDefinition extends cElementalDefinition {
         for (cElementalDefinitionStack stack : elementalStacks.values())
             anti.putReplace(new cElementalDefinitionStack(stack.definition.getAnti(), stack.amount));
         try {
-            return new dAtomDefinition(anti.toImmutable());
+            return new dAtomDefinition(anti.toImmutable_unsafeMightLeaveExposedElementalTree());
         } catch (tElementalException e) {
             if (DEBUG_MODE) e.printStackTrace();
             return null;
@@ -822,11 +1112,37 @@ public final class dAtomDefinition extends cElementalDefinition {
                 if (DEBUG_MODE)
                     TecTech.Logger.info("Added Unstable Atom:" + key + " " + mostStableUnstableIsotopes.get(key).lastEntry().getValue() + " " + unstableAtoms.get(key).getMass());
             }
-            alpha = new cElementalDefinitionStack(
-                    new dAtomDefinition(
-                            new cElementalDefinitionStack(dHadronDefinition.hadron_p, 2),
-                            new cElementalDefinitionStack(dHadronDefinition.hadron_n, 2))
-                    , 1);
+            deuterium=new dAtomDefinition(
+                    dHadronDefinition.hadron_p1,
+                    dHadronDefinition.hadron_n1,
+                    eLeptonDefinition.lepton_e1).getStackForm(1);
+            tritium=new dAtomDefinition(
+                    dHadronDefinition.hadron_p1,
+                    dHadronDefinition.hadron_n2,
+                    eLeptonDefinition.lepton_e1).getStackForm(1);
+            helium_3=new dAtomDefinition(
+                    dHadronDefinition.hadron_p2,
+                    dHadronDefinition.hadron_n1,
+                    eLeptonDefinition.lepton_e2).getStackForm(1);
+            alpha = new dAtomDefinition(
+                    dHadronDefinition.hadron_p2,
+                    dHadronDefinition.hadron_n2).getStackForm(1);
+            beryllium_8=new dAtomDefinition(
+                    new cElementalDefinitionStack(dHadronDefinition.hadron_p, 4),
+                    new cElementalDefinitionStack(dHadronDefinition.hadron_n, 4),
+                    new cElementalDefinitionStack(eLeptonDefinition.lepton_e, 4)).getStackForm(1);
+            carbon_14=new dAtomDefinition(
+                    new cElementalDefinitionStack(dHadronDefinition.hadron_p, 6),
+                    new cElementalDefinitionStack(dHadronDefinition.hadron_n, 8),
+                    new cElementalDefinitionStack(eLeptonDefinition.lepton_e, 6)).getStackForm(1);
+            neon_24=new dAtomDefinition(
+                    new cElementalDefinitionStack(dHadronDefinition.hadron_p, 10),
+                    new cElementalDefinitionStack(dHadronDefinition.hadron_n, 14),
+                    new cElementalDefinitionStack(eLeptonDefinition.lepton_e, 10)).getStackForm(1);
+            silicon_34=new dAtomDefinition(
+                    new cElementalDefinitionStack(dHadronDefinition.hadron_p, 14),
+                    new cElementalDefinitionStack(dHadronDefinition.hadron_n, 20),
+                    new cElementalDefinitionStack(eLeptonDefinition.lepton_e, 14)).getStackForm(1);
         } catch (Exception e) {
             if (DEBUG_MODE) e.printStackTrace();
         }
@@ -944,36 +1260,13 @@ public final class dAtomDefinition extends cElementalDefinition {
         ////transformation.addOredict(new cElementalDefinitionStack(getBestUnstableIsotope(94),144), dust, Materials.Plutonium,1);
         transformation.addOredict(new cElementalDefinitionStack(getBestUnstableIsotope(95),144), dust, Materials.Americium,1);
 
-        /* ... */
-        cElementalDefinitionStack neutrons=new cElementalDefinitionStack(dHadronDefinition.hadron_n, 100000);
-        transformation.oredictDequantization.put(neutrons.definition,new aOredictDequantizationInfo(neutrons, dust,Materials.Neutronium,1));
-        bTransformationInfo.oredictQuantization.put(
-                OreDictionary.getOreID(OrePrefixes.ingotHot.name()+Materials.Neutronium.mName),
-                new aOredictQuantizationInfo(OrePrefixes.ingotHot,Materials.Neutronium,1 ,neutrons)
-        );
-
         try {
             dAtomDefinition temp;
-            temp=new dAtomDefinition(
-                    eLeptonDefinition.lepton_e1,
-                    dHadronDefinition.hadron_p1,
-                    dHadronDefinition.hadron_n1
-            );
-            transformation.addFluid(new cElementalDefinitionStack(temp, 144),Materials.Deuterium.mGas.getID(), 144);
+            transformation.addFluid(new cElementalDefinitionStack(deuterium.definition, 144),Materials.Deuterium.mGas.getID(), 144);
 
-            temp=new dAtomDefinition(
-                    eLeptonDefinition.lepton_e1,
-                    dHadronDefinition.hadron_p1,
-                    dHadronDefinition.hadron_n2
-            );
-            transformation.addFluid(new cElementalDefinitionStack(temp, 144),Materials.Tritium.mGas.getID(), 144);
+            transformation.addFluid(new cElementalDefinitionStack(tritium.definition, 144),Materials.Tritium.mGas.getID(), 144);
 
-            temp=new dAtomDefinition(
-                    new cElementalDefinitionStack(eLeptonDefinition.lepton_e, 2),
-                    dHadronDefinition.hadron_p2,
-                    new cElementalDefinitionStack(dHadronDefinition.hadron_n, 3)
-            );
-            transformation.addFluid(new cElementalDefinitionStack(temp, 144),Materials.Helium_3.mGas.getID(), 144);
+            transformation.addFluid(new cElementalDefinitionStack(helium_3.definition, 144),Materials.Helium_3.mGas.getID(), 144);
 
             temp=new dAtomDefinition(
                     new cElementalDefinitionStack(eLeptonDefinition.lepton_e, 92),
diff --git a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/dHadronDefinition.java b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/dHadronDefinition.java
index aa839ee71a..e15ca05bf3 100644
--- a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/dHadronDefinition.java
+++ b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/dHadronDefinition.java
@@ -9,17 +9,20 @@ import com.github.technus.tectech.elementalMatter.core.containers.cElementalDefi
 import com.github.technus.tectech.elementalMatter.core.interfaces.iElementalDefinition;
 import com.github.technus.tectech.elementalMatter.core.tElementalException;
 import com.github.technus.tectech.elementalMatter.core.templates.cElementalDefinition;
-import com.github.technus.tectech.elementalMatter.core.transformations.aFluidDequantizationInfo;
-import com.github.technus.tectech.elementalMatter.core.transformations.aItemDequantizationInfo;
-import com.github.technus.tectech.elementalMatter.core.transformations.aOredictDequantizationInfo;
+import com.github.technus.tectech.elementalMatter.core.transformations.*;
 import com.github.technus.tectech.elementalMatter.definitions.primitive.eBosonDefinition;
 import com.github.technus.tectech.elementalMatter.definitions.primitive.eQuarkDefinition;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
 import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.oredict.OreDictionary;
 
 import java.util.ArrayList;
 
 import static com.github.technus.tectech.auxiliary.TecTechConfig.DEBUG_MODE;
+import static com.github.technus.tectech.elementalMatter.definitions.complex.dAtomDefinition.transformation;
 import static com.github.technus.tectech.elementalMatter.definitions.primitive.eBosonDefinition.boson_Y__;
+import static gregtech.api.enums.OrePrefixes.dust;
 
 /**
  * Created by danie_000 on 17.11.2016.
@@ -30,7 +33,7 @@ public final class dHadronDefinition extends cElementalDefinition {//TODO Optimi
     private static final byte nbtType = (byte) 'h';
     //Helpers
     public static dHadronDefinition hadron_p, hadron_n, hadron_p_, hadron_n_;
-    public static cElementalDefinitionStack hadron_p1, hadron_n1, hadron_p2, hadron_n2;
+    public static cElementalDefinitionStack hadron_p1, hadron_n1, hadron_p2, hadron_n2, hadron_p3, hadron_n3;
     private static float protonMass = 0F;
     private static float neutronMass = 0F;
 
@@ -291,7 +294,7 @@ public final class dHadronDefinition extends cElementalDefinition {//TODO Optimi
         for (cElementalDefinitionStack stack : quarkStacks.values())
             anti.putReplace(new cElementalDefinitionStack(stack.definition.getAnti(), stack.amount));
         try {
-            return new dHadronDefinition(anti.toImmutable());
+            return new dHadronDefinition(anti.toImmutable_unsafeMightLeaveExposedElementalTree());
         } catch (tElementalException e) {
             if (TecTechConfig.DEBUG_MODE) e.printStackTrace();
             return null;
@@ -357,6 +360,8 @@ public final class dHadronDefinition extends cElementalDefinition {//TODO Optimi
         hadron_n1 = new cElementalDefinitionStack(hadron_n, 1);
         hadron_p2 = new cElementalDefinitionStack(hadron_p, 2);
         hadron_n2 = new cElementalDefinitionStack(hadron_n, 2);
+        hadron_p3 = new cElementalDefinitionStack(hadron_p, 3);
+        hadron_n3 = new cElementalDefinitionStack(hadron_n, 3);
 
         try {
             cElementalDefinition.addCreatorFromNBT(nbtType, dHadronDefinition.class.getMethod("fromNBT", NBTTagCompound.class),(byte)-64);
@@ -367,6 +372,16 @@ public final class dHadronDefinition extends cElementalDefinition {//TODO Optimi
             TecTech.Logger.info("Registered Elemental Matter Class: Hadron "+nbtType+" "+(-64));
     }
 
+    public static void setTransformations(){
+        //Added to atom map, but should be in its own
+        cElementalDefinitionStack neutrons=new cElementalDefinitionStack(dHadronDefinition.hadron_n, 100000);
+        transformation.oredictDequantization.put(neutrons.definition,new aOredictDequantizationInfo(neutrons, dust, Materials.Neutronium,1));
+        bTransformationInfo.oredictQuantization.put(
+                OreDictionary.getOreID(OrePrefixes.ingotHot.name()+Materials.Neutronium.mName),
+                new aOredictQuantizationInfo(OrePrefixes.ingotHot,Materials.Neutronium,1 ,neutrons)
+        );
+    }
+
     @Override
     public byte getClassType() {
         return -64;
diff --git a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/iaea/iaeaNuclide.java b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/iaea/iaeaNuclide.java
index 31fda970a6..2bb9efffb8 100644
--- a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/iaea/iaeaNuclide.java
+++ b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/complex/iaea/iaeaNuclide.java
@@ -9,6 +9,7 @@ import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.TreeMap;
 
 import static com.github.technus.tectech.elementalMatter.core.interfaces.iElementalDefinition.STABLE_RAW_LIFE_TIME;
@@ -111,9 +112,9 @@ public final class iaeaNuclide {
     }
 
     private void getMoreData(String[] cells){
-        //if(add(cells[14]))System.out.println(N+" "+Z);
-        //if(add(cells[17]))System.out.println(N+" "+Z);
-        //if(add(cells[20]))System.out.println(N+" "+Z);
+        if(add(cells[14]))System.out.println(N+" "+Z);
+        if(add(cells[17]))System.out.println(N+" "+Z);
+        if(add(cells[20]))System.out.println(N+" "+Z);
         new energeticState(this, halfTime,getDecaysFixed(cells[14],doubleOrNaN(cells[15],"chance1"),cells[17],doubleOrNaN(cells[18],"chance1"),cells[20],doubleOrNaN(cells[21],"chance1")));
     }
 
@@ -164,9 +165,9 @@ public final class iaeaNuclide {
             }
             nuclide.energeticStates.put(energy,this);
 
-            //if(add(cells[12]))System.out.println(nuclide.N+" "+nuclide.Z);
-            //if(add(cells[15]))System.out.println(nuclide.N+" "+nuclide.Z);
-            //if(add(cells[18]))System.out.println(nuclide.N+" "+nuclide.Z);
+            if(add(cells[12]))System.out.println(nuclide.N+" "+nuclide.Z);
+            if(add(cells[15]))System.out.println(nuclide.N+" "+nuclide.Z);
+            if(add(cells[18]))System.out.println(nuclide.N+" "+nuclide.Z);
             this.decaymodes=getDecaysFixed(cells[12],doubleOrNaN(cells[13],"chance 1",nuclide),cells[15],doubleOrNaN(cells[16],"chance 2",nuclide),cells[18],doubleOrNaN(cells[19],"chance 3",nuclide));
         }
 
@@ -192,15 +193,15 @@ public final class iaeaNuclide {
         }
     }
 
-    //private static HashSet<String> decays=new HashSet<>();
-    //private static boolean add(String s){
-    //    int len=decays.size();
-    //    if(decays.add(s)){
-    //        System.out.println(s);
-    //        return true;
-    //    }
-    //    return false;
-    //}
+    private static HashSet<String> decays=new HashSet<>();
+    private static boolean add(String s){
+        int len=decays.size();
+        if(decays.add(s)){
+            System.out.println(s);
+            return true;
+        }
+        return false;
+    }
 
     private static iaeaDecay[] getDecaysFixed(String decay1, double chance1,String decay2, double chance2,String decay3, double chance3){
         TreeMap<Double,iaeaDecay> decays=new TreeMap<>();
diff --git a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/primitive/eLeptonDefinition.java b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/primitive/eLeptonDefinition.java
index 3ef4e4b258..2f13fae24f 100644
--- a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/primitive/eLeptonDefinition.java
+++ b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/primitive/eLeptonDefinition.java
@@ -17,7 +17,9 @@ public final class eLeptonDefinition extends cElementalPrimitive {
             lepton_t_ = new eLeptonDefinition("Antitauon", "\u03c4+", -3, 1776.83e6F, 3, -1, 20);
 
     public static final cElementalDefinitionStack lepton_e1 = new cElementalDefinitionStack(lepton_e, 1);
+    public static final cElementalDefinitionStack lepton_e2 = new cElementalDefinitionStack(lepton_e, 2);
     public static final cElementalDefinitionStack lepton_e_1 = new cElementalDefinitionStack(lepton_e_, 1);
+    public static final cElementalDefinitionStack lepton_e_2 = new cElementalDefinitionStack(lepton_e_, 2);
 
     private eLeptonDefinition(String name, String symbol, int type, float mass, int charge, int color, int ID) {
         super(name, symbol, type, mass, charge, color, ID);
diff --git a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/primitive/eNeutrinoDefinition.java b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/primitive/eNeutrinoDefinition.java
index 07e7452144..673dba7b77 100644
--- a/src/main/java/com/github/technus/tectech/elementalMatter/definitions/primitive/eNeutrinoDefinition.java
+++ b/src/main/java/com/github/technus/tectech/elementalMatter/definitions/primitive/eNeutrinoDefinition.java
@@ -17,7 +17,9 @@ public final class eNeutrinoDefinition extends cElementalPrimitive {
             lepton_Vt_ = new eNeutrinoDefinition("Antitauon neutrino", "~\u03bd\u03c4", -3, 15e6F, 0, -1, 26);
 
     public static final cElementalDefinitionStack lepton_Ve1 = new cElementalDefinitionStack(lepton_Ve, 1);
+    public static final cElementalDefinitionStack lepton_Ve2 = new cElementalDefinitionStack(lepton_Ve, 2);
     public static final cElementalDefinitionStack lepton_Ve_1 = new cElementalDefinitionStack(lepton_Ve_, 1);
+    public static final cElementalDefinitionStack lepton_Ve_2 = new cElementalDefinitionStack(lepton_Ve_, 2);
 
     private eNeutrinoDefinition(String name, String symbol, int type, float mass, int charge, int color, int ID) {
         super(name, symbol, type, mass, charge, color, ID);
diff --git a/src/main/java/com/github/technus/tectech/loader/RecipeLoader.java b/src/main/java/com/github/technus/tectech/loader/RecipeLoader.java
index 601552e33e..f4883b10db 100644
--- a/src/main/java/com/github/technus/tectech/loader/RecipeLoader.java
+++ b/src/main/java/com/github/technus/tectech/loader/RecipeLoader.java
@@ -2,6 +2,7 @@ package com.github.technus.tectech.loader;
 
 import com.github.technus.tectech.compatibility.dreamcraft.DreamCraftRecipeLoader;
 import com.github.technus.tectech.elementalMatter.definitions.complex.dAtomDefinition;
+import com.github.technus.tectech.elementalMatter.definitions.complex.dHadronDefinition;
 import com.github.technus.tectech.thing.casing.TT_Container_Casings;
 import cpw.mods.fml.common.Loader;
 import gregtech.api.enums.Materials;
@@ -18,6 +19,7 @@ import static gregtech.api.enums.GT_Values.RA;
 public class RecipeLoader implements Runnable {
     public void run() {
         dAtomDefinition.setTransformation();
+        dHadronDefinition.setTransformations();
 
         // ===================================================================================================
         // Recipes init - common goes here rest goes into methods below