diff --git a/Editor/Data/ConstFieldAllocator.cs b/Editor/Data/ConstFieldAllocator.cs
index d173fc1..90f889d 100644
--- a/Editor/Data/ConstFieldAllocator.cs
+++ b/Editor/Data/ConstFieldAllocator.cs
@@ -10,13 +10,8 @@ using UnityEngine.Assertions;
 
 namespace Obfuz.Data
 {
-    public class ModuleConstFieldAllocator : IGroupByModuleEntity
+    public class ConstFieldAllocator : GroupByModuleEntityBase
     {
-        private ModuleDef _module;
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private readonly RvaDataAllocator _rvaDataAllocator;
-        private readonly GroupByModuleEntityManager _moduleEntityManager;
-        private EncryptionScopeInfo _encryptionScope;
         private RandomCreator _randomCreator;
         private IEncryptor _encryptor;
 
@@ -57,19 +52,14 @@ namespace Obfuz.Data
         private bool _done;
 
 
-        public ModuleConstFieldAllocator(EncryptionScopeProvider encryptionScopeProvider, RvaDataAllocator rvaDataAllocator, GroupByModuleEntityManager moduleEntityManager)
+        public ConstFieldAllocator()
         {
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _rvaDataAllocator = rvaDataAllocator;
-            _moduleEntityManager = moduleEntityManager;
         }
 
-        public void Init(ModuleDef mod)
+        public override void Init()
         {
-            _module = mod;
-            _encryptionScope = _encryptionScopeProvider.GetScope(mod);
-            _randomCreator = _encryptionScope.localRandomCreator;
-            _encryptor = _encryptionScope.encryptor;
+            _randomCreator = EncryptionScope.localRandomCreator;
+            _encryptor = EncryptionScope.encryptor;
         }
 
         const int maxFieldCount = 1000;
@@ -77,30 +67,32 @@ namespace Obfuz.Data
 
         private TypeSig GetTypeSigOfValue(object value)
         {
+            ModuleDef mod = Module;
             if (value is int)
-                return _module.CorLibTypes.Int32;
+                return mod.CorLibTypes.Int32;
             if (value is long)
-                return _module.CorLibTypes.Int64;
+                return mod.CorLibTypes.Int64;
             if (value is float)
-                return _module.CorLibTypes.Single;
+                return mod.CorLibTypes.Single;
             if (value is double)
-                return _module.CorLibTypes.Double;
+                return mod.CorLibTypes.Double;
             if (value is string)
-                return _module.CorLibTypes.String;
+                return mod.CorLibTypes.String;
             if (value is byte[])
-                return new SZArraySig(_module.CorLibTypes.Byte);
+                return new SZArraySig(mod.CorLibTypes.Byte);
             throw new NotSupportedException($"Unsupported type: {value.GetType()}");
         }
 
         private ConstFieldInfo CreateConstFieldInfo(object value)
         {
+            ModuleDef mod = Module;
             if (_holderTypeDef == null || _holderTypeDef.Fields.Count >= maxFieldCount)
             {
-                using (var scope = new DisableTypeDefFindCacheScope(_module))
+                using (var scope = new DisableTypeDefFindCacheScope(mod))
                 {
-                    ITypeDefOrRef objectTypeRef = _module.Import(typeof(object));
+                    ITypeDefOrRef objectTypeRef = mod.Import(typeof(object));
                     _holderTypeDef = new TypeDefUser($"{ConstValues.ObfuzInternalSymbolNamePrefix}ConstFieldHolder${_holderTypeDefs.Count}", objectTypeRef);
-                    _module.Types.Add(_holderTypeDef);
+                    mod.Types.Add(_holderTypeDef);
                     _holderTypeDefs.Add(_holderTypeDef);
                 }
             }
@@ -159,28 +151,22 @@ namespace Obfuz.Data
             return AllocateAny(value);
         }
 
-        private DefaultMetadataImporter GetModuleMetadataImporter()
-        {
-            return _moduleEntityManager.GetDefaultModuleMetadataImporter(_module, _encryptionScopeProvider);
-        }
 
         private void CreateCCtorOfRvaTypeDef(TypeDef type)
         {
+            ModuleDef mod = Module;
             var cctor = new MethodDefUser(".cctor",
-                MethodSig.CreateStatic(_module.CorLibTypes.Void),
+                MethodSig.CreateStatic(mod.CorLibTypes.Void),
                 MethodImplAttributes.IL | MethodImplAttributes.Managed,
                 MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.Private);
             cctor.DeclaringType = type;
-            //_rvaTypeDef.Methods.Add(cctor);
             var body = new CilBody();
             cctor.Body = body;
             var ins = body.Instructions;
 
-            //IMethod method = _module.Import(typeof(System.Runtime.CompilerServices.RuntimeHelpers).GetMethod("InitializeArray", new[] { typeof(Array), typeof(RuntimeFieldHandle) }));
-            //Assert.IsNotNull(method);
 
-
-            DefaultMetadataImporter importer = GetModuleMetadataImporter();
+            DefaultMetadataImporter importer = this.GetDefaultModuleMetadataImporter();
+            RvaDataAllocator rvaDataAllocator = GetEntity<RvaDataAllocator>();
             // TODO. obfuscate init codes
             foreach (var field in type.Fields)
             {
@@ -193,7 +179,7 @@ namespace Obfuz.Data
                     case int i:
                     {
                         int encryptedValue = _encryptor.Encrypt(i, ops, salt);
-                        RvaData rvaData = _rvaDataAllocator.Allocate(_module, encryptedValue);
+                        RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
                         ins.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
                         ins.Add(Instruction.CreateLdcI4(rvaData.offset));
                         ins.Add(Instruction.CreateLdcI4(ops));
@@ -204,7 +190,7 @@ namespace Obfuz.Data
                     case long l:
                     {
                         long encryptedValue = _encryptor.Encrypt(l, ops, salt);
-                        RvaData rvaData = _rvaDataAllocator.Allocate(_module, encryptedValue);
+                        RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
                         ins.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
                         ins.Add(Instruction.CreateLdcI4(rvaData.offset));
                         ins.Add(Instruction.CreateLdcI4(ops));
@@ -215,7 +201,7 @@ namespace Obfuz.Data
                     case float f:
                     {
                         float encryptedValue = _encryptor.Encrypt(f, ops, salt);
-                        RvaData rvaData = _rvaDataAllocator.Allocate(_module, encryptedValue);
+                        RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
                         ins.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
                         ins.Add(Instruction.CreateLdcI4(rvaData.offset));
                         ins.Add(Instruction.CreateLdcI4(ops));
@@ -226,7 +212,7 @@ namespace Obfuz.Data
                     case double d:
                     {
                         double encryptedValue = _encryptor.Encrypt(d, ops, salt);
-                        RvaData rvaData = _rvaDataAllocator.Allocate(_module, encryptedValue);
+                        RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
                         ins.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
                         ins.Add(Instruction.CreateLdcI4(rvaData.offset));
                         ins.Add(Instruction.CreateLdcI4(ops));
@@ -237,7 +223,7 @@ namespace Obfuz.Data
                     case string s:
                     {
                         byte[] encryptedValue = _encryptor.Encrypt(s, ops, salt);
-                        RvaData rvaData = _rvaDataAllocator.Allocate(_module, encryptedValue);
+                        RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
                         ins.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
                         ins.Add(Instruction.CreateLdcI4(rvaData.offset));
                         Assert.AreEqual(encryptedValue.Length, rvaData.size);
@@ -251,7 +237,7 @@ namespace Obfuz.Data
                     {
                         byte[] encryptedValue = _encryptor.Encrypt(bs, 0, bs.Length, ops, salt);
                         Assert.AreEqual(encryptedValue.Length, bs.Length);
-                        RvaData rvaData = _rvaDataAllocator.Allocate(_module, encryptedValue);
+                        RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
                         ins.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
                         ins.Add(Instruction.CreateLdcI4(rvaData.offset));
                         ins.Add(Instruction.CreateLdcI4(bs.Length));
@@ -267,7 +253,7 @@ namespace Obfuz.Data
             ins.Add(Instruction.Create(OpCodes.Ret));
         }
 
-        public void Done()
+        public override void Done()
         {
             if (_done)
             {
@@ -280,61 +266,4 @@ namespace Obfuz.Data
             }
         }
     }
-
-    public class ConstFieldAllocator
-    {
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private readonly RvaDataAllocator _rvaDataAllocator;
-        private readonly GroupByModuleEntityManager _moduleEntityManager;
-
-        public ConstFieldAllocator(EncryptionScopeProvider encryptionScopeProvider, RvaDataAllocator rvaDataAllocator, GroupByModuleEntityManager moduleEntityManager)
-        {
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _rvaDataAllocator = rvaDataAllocator;
-            _moduleEntityManager = moduleEntityManager;
-        }
-
-        public ModuleConstFieldAllocator GetModuleAllocator(ModuleDef mod)
-        {
-            return _moduleEntityManager.GetEntity<ModuleConstFieldAllocator>(mod, () => new ModuleConstFieldAllocator(_encryptionScopeProvider, _rvaDataAllocator, _moduleEntityManager));
-        }
-
-        public FieldDef Allocate(ModuleDef mod, int value)
-        {
-            return GetModuleAllocator(mod).Allocate(value);
-        }
-
-        public FieldDef Allocate(ModuleDef mod, long value)
-        {
-            return GetModuleAllocator(mod).Allocate(value);
-        }
-
-        public FieldDef Allocate(ModuleDef mod, float value)
-        {
-            return GetModuleAllocator(mod).Allocate(value);
-        }
-
-        public FieldDef Allocate(ModuleDef mod, double value)
-        {
-            return GetModuleAllocator(mod).Allocate(value);
-        }
-
-        public FieldDef Allocate(ModuleDef mod, byte[] value)
-        {
-            return GetModuleAllocator(mod).Allocate(value);
-        }
-
-        public FieldDef Allocate(ModuleDef mod, string value)
-        {
-            return GetModuleAllocator(mod).Allocate(value);
-        }
-
-        public void Done()
-        {
-            foreach (var moduleAllocator in _moduleEntityManager.GetEntities<ModuleConstFieldAllocator>())
-            {
-                moduleAllocator.Done();
-            }
-        }
-    }
 }
diff --git a/Editor/Data/RvaDataAllocator.cs b/Editor/Data/RvaDataAllocator.cs
index 8827ee0..1137777 100644
--- a/Editor/Data/RvaDataAllocator.cs
+++ b/Editor/Data/RvaDataAllocator.cs
@@ -4,6 +4,7 @@ using Obfuz.Emit;
 using Obfuz.Utils;
 using System;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
 using System.Text;
 using UnityEngine.Assertions;
 
@@ -23,16 +24,11 @@ namespace Obfuz.Data
         }
     }
 
-    public class ModuleRvaDataAllocator : GroupByModuleEntityBase
+    public class RvaDataAllocator : GroupByModuleEntityBase
     {
         // randomized
         const int maxRvaDataSize = 0x1000;
 
-        private ModuleDef _module;
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private readonly GroupByModuleEntityManager _moduleEntityManager;
-
-        private EncryptionScopeInfo _encryptionScope;
         private IRandom _random;
 
         class RvaField
@@ -71,28 +67,23 @@ namespace Obfuz.Data
         private readonly Dictionary<int, TypeDef> _dataHolderTypeBySizes = new Dictionary<int, TypeDef>();
         private bool _done;
 
-        public ModuleRvaDataAllocator(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager)
+        public RvaDataAllocator()
         {
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _moduleEntityManager = moduleEntityManager;
         }
 
-        public override void Init(ModuleDef mod)
+        public override void Init()
         {
-            _module = mod;
-            _encryptionScope = _encryptionScopeProvider.GetScope(mod);
-            _random = _encryptionScope.localRandomCreator(HashUtil.ComputeHash(mod.Name));
+            _random = EncryptionScope.localRandomCreator(HashUtil.ComputeHash(Module.Name));
         }
 
         private (FieldDef, FieldDef) CreateDataHolderRvaField(TypeDef dataHolderType)
         {
             if (_rvaTypeDef == null)
             {
-                using (var scope = new DisableTypeDefFindCacheScope(_module))
+                using (var scope = new DisableTypeDefFindCacheScope(Module))
                 {
-                    ITypeDefOrRef objectTypeRef = _module.Import(typeof(object));
-                    _rvaTypeDef = new TypeDefUser("$Obfuz$RVA$", objectTypeRef);
-                    _module.Types.Add(_rvaTypeDef);
+                    _rvaTypeDef = new TypeDefUser("$Obfuz$RVA$", Module.CorLibTypes.Object.ToTypeDefOrRef());
+                    Module.Types.Add(_rvaTypeDef);
                 }
             }
 
@@ -100,7 +91,7 @@ namespace Obfuz.Data
             var holderField = new FieldDefUser($"$RVA_Data{_rvaFields.Count}", new FieldSig(dataHolderType.ToTypeSig()), FieldAttributes.InitOnly | FieldAttributes.Static | FieldAttributes.HasFieldRVA);
             holderField.DeclaringType = _rvaTypeDef;
 
-            var runtimeValueField = new FieldDefUser($"$RVA_Value{_rvaFields.Count}", new FieldSig(new SZArraySig(_module.CorLibTypes.Byte)), FieldAttributes.Static | FieldAttributes.Public);
+            var runtimeValueField = new FieldDefUser($"$RVA_Value{_rvaFields.Count}", new FieldSig(new SZArraySig(Module.CorLibTypes.Byte)), FieldAttributes.Static | FieldAttributes.Public);
             runtimeValueField.DeclaringType = _rvaTypeDef;
             return (holderField, runtimeValueField);
         }
@@ -111,15 +102,15 @@ namespace Obfuz.Data
             if (_dataHolderTypeBySizes.TryGetValue(size, out var type))
                 return type;
 
-            using (var scope = new DisableTypeDefFindCacheScope(_module))
+            using (var scope = new DisableTypeDefFindCacheScope(Module))
             {
-                var dataHolderType = new TypeDefUser($"$ObfuzRVA$DataHolder{size}", _module.Import(typeof(ValueType)));
+                var dataHolderType = new TypeDefUser($"$ObfuzRVA$DataHolder{size}", Module.Import(typeof(ValueType)));
                 dataHolderType.Attributes = TypeAttributes.Public | TypeAttributes.Sealed;
                 dataHolderType.Layout = TypeAttributes.ExplicitLayout;
                 dataHolderType.PackingSize = 1;
                 dataHolderType.ClassSize = (uint)size;
                 _dataHolderTypeBySizes.Add(size, dataHolderType);
-                _module.Types.Add(dataHolderType);
+                Module.Types.Add(dataHolderType);
                 return dataHolderType;
             }
         }
@@ -230,10 +221,11 @@ namespace Obfuz.Data
         private void AddVerifyCodes(IList<Instruction> insts, DefaultMetadataImporter importer)
         {
             int verifyIntValue = 0x12345678;
-            IRandom verifyRandom = _encryptionScope.localRandomCreator(verifyIntValue);
-            int verifyOps = EncryptionUtil.GenerateEncryptionOpCodes(verifyRandom, _encryptionScope.encryptor, 4);
+            EncryptionScopeInfo encryptionScope = this.EncryptionScope;
+            IRandom verifyRandom = encryptionScope.localRandomCreator(verifyIntValue);
+            int verifyOps = EncryptionUtil.GenerateEncryptionOpCodes(verifyRandom, encryptionScope.encryptor, 4);
             int verifySalt = verifyRandom.NextInt();
-            int encryptedVerifyIntValue = _encryptionScope.encryptor.Encrypt(verifyIntValue, verifyOps, verifySalt);
+            int encryptedVerifyIntValue = encryptionScope.encryptor.Encrypt(verifyIntValue, verifyOps, verifySalt);
 
             insts.Add(Instruction.Create(OpCodes.Ldc_I4, verifyIntValue));
             insts.Add(Instruction.CreateLdcI4(encryptedVerifyIntValue));
@@ -252,7 +244,7 @@ namespace Obfuz.Data
             }
             ModuleDef mod = _rvaTypeDef.Module;
             var cctorMethod = new MethodDefUser(".cctor",
-                MethodSig.CreateStatic(_module.CorLibTypes.Void),
+                MethodSig.CreateStatic(Module.CorLibTypes.Void),
                 MethodImplAttributes.IL | MethodImplAttributes.Managed,
                 MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.Private);
             cctorMethod.DeclaringType = _rvaTypeDef;
@@ -261,7 +253,7 @@ namespace Obfuz.Data
             cctorMethod.Body = body;
             var ins = body.Instructions;
 
-            DefaultMetadataImporter importer = _moduleEntityManager.GetDefaultModuleMetadataImporter(mod, _encryptionScopeProvider);
+            DefaultMetadataImporter importer = this.GetDefaultModuleMetadataImporter();
             AddVerifyCodes(ins, importer);
             foreach (var field in _rvaFields)
             {
@@ -298,7 +290,7 @@ namespace Obfuz.Data
                     field.FillPaddingToEnd();
                 }
                 byte[] data = field.bytes.ToArray();
-                _encryptionScope.encryptor.EncryptBlock(data, field.encryptionOps, field.salt);
+                EncryptionScope.encryptor.EncryptBlock(data, field.encryptionOps, field.salt);
                 field.holderDataField.InitialValue = data;
             }
         }
@@ -314,59 +306,4 @@ namespace Obfuz.Data
             CreateCCtorOfRvaTypeDef();
         }
     }
-
-    public class RvaDataAllocator
-    {
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private readonly GroupByModuleEntityManager _moduleEntityManager;
-
-        public RvaDataAllocator(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager)
-        {
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _moduleEntityManager = moduleEntityManager;
-        }
-
-        private ModuleRvaDataAllocator GetModuleRvaDataAllocator(ModuleDef mod)
-        {
-            return _moduleEntityManager.GetEntity<ModuleRvaDataAllocator>(mod, () => new ModuleRvaDataAllocator(_encryptionScopeProvider, _moduleEntityManager));
-        }
-
-        public RvaData Allocate(ModuleDef mod, int value)
-        {
-            return GetModuleRvaDataAllocator(mod).Allocate(value);
-        }
-
-        public RvaData Allocate(ModuleDef mod, long value)
-        {
-            return GetModuleRvaDataAllocator(mod).Allocate(value);
-        }
-
-        public RvaData Allocate(ModuleDef mod, float value)
-        {
-            return GetModuleRvaDataAllocator(mod).Allocate(value);
-        }
-
-        public RvaData Allocate(ModuleDef mod, double value)
-        {
-            return GetModuleRvaDataAllocator(mod).Allocate(value);
-        }
-
-        public RvaData Allocate(ModuleDef mod, string value)
-        {
-            return GetModuleRvaDataAllocator(mod).Allocate(value);
-        }
-
-        public RvaData Allocate(ModuleDef mod, byte[] value)
-        {
-            return GetModuleRvaDataAllocator(mod).Allocate(value);
-        }
-
-        public void Done()
-        {
-            foreach (var allocator in _moduleEntityManager.GetEntities<ModuleRvaDataAllocator>())
-            {
-                allocator.Done();
-            }
-        }
-    }
 }
diff --git a/Editor/Emit/DefaultMetadataImporter.cs b/Editor/Emit/DefaultMetadataImporter.cs
index eb977f2..3d7a7e5 100644
--- a/Editor/Emit/DefaultMetadataImporter.cs
+++ b/Editor/Emit/DefaultMetadataImporter.cs
@@ -111,23 +111,20 @@ namespace Obfuz.Emit
 
     public class DefaultMetadataImporter : GroupByModuleEntityBase
     {
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private EncryptionScopeInfo _encryptionScope;
         private EncryptionServiceMetadataImporter _defaultEncryptionServiceMetadataImporter;
 
 
         private EncryptionServiceMetadataImporter _staticDefaultEncryptionServiceMetadataImporter;
         private EncryptionServiceMetadataImporter _dynamicDefaultEncryptionServiceMetadataImporter;
 
-        public DefaultMetadataImporter(EncryptionScopeProvider encryptionScopeProvider)
+        public DefaultMetadataImporter()
         {
-            _encryptionScopeProvider = encryptionScopeProvider;
         }
 
-        public override void Init(ModuleDef mod)
+        public override void Init()
         {
-            _module = mod;
-            _encryptionScope = _encryptionScopeProvider.GetScope(mod);
+            ModuleDef mod = Module;
+
             var constUtilityType = typeof(ConstUtility);
 
             _castIntAsFloat = mod.Import(constUtilityType.GetMethod("CastIntAsFloat"));
@@ -238,7 +235,7 @@ namespace Obfuz.Emit
 
             _staticDefaultEncryptionServiceMetadataImporter = new EncryptionServiceMetadataImporter(mod, typeof(EncryptionService<DefaultStaticEncryptionScope>));
             _dynamicDefaultEncryptionServiceMetadataImporter = new EncryptionServiceMetadataImporter(mod, typeof(EncryptionService<DefaultDynamicEncryptionScope>));
-            if (_encryptionScopeProvider.IsDynamicSecretAssembly(mod))
+            if (EncryptionScopeProvider.IsDynamicSecretAssembly(mod))
             {
                 _defaultEncryptionServiceMetadataImporter = _dynamicDefaultEncryptionServiceMetadataImporter;
             }
@@ -255,7 +252,7 @@ namespace Obfuz.Emit
 
         public EncryptionServiceMetadataImporter GetEncryptionServiceMetadataImporterOfModule(ModuleDef mod)
         {
-            return _encryptionScopeProvider.IsDynamicSecretAssembly(mod) ? _dynamicDefaultEncryptionServiceMetadataImporter : _staticDefaultEncryptionServiceMetadataImporter;
+            return EncryptionScopeProvider.IsDynamicSecretAssembly(mod) ? _dynamicDefaultEncryptionServiceMetadataImporter : _staticDefaultEncryptionServiceMetadataImporter;
         }
 
         private ModuleDef _module;
diff --git a/Editor/Emit/EntityExtensions.cs b/Editor/Emit/EntityExtensions.cs
new file mode 100644
index 0000000..7bc9880
--- /dev/null
+++ b/Editor/Emit/EntityExtensions.cs
@@ -0,0 +1,15 @@
+namespace Obfuz.Emit
+{
+    public static class EntityExtensions
+    {
+        public static T GetEntity<T>(this IGroupByModuleEntity entity) where T : IGroupByModuleEntity, new()
+        {
+            return entity.Manager.GetEntity<T>(entity.Module);
+        }
+
+        public static DefaultMetadataImporter GetDefaultModuleMetadataImporter(this IGroupByModuleEntity entity)
+        {
+            return entity.GetEntity<DefaultMetadataImporter>();
+        }
+    }
+}
diff --git a/Editor/Emit/EntityExtensions.cs.meta b/Editor/Emit/EntityExtensions.cs.meta
new file mode 100644
index 0000000..119466e
--- /dev/null
+++ b/Editor/Emit/EntityExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6e9557733f180764692756653eb60f88
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Editor/Emit/GroupByModuleEntityManager.cs b/Editor/Emit/GroupByModuleEntityManager.cs
index 5745cf2..97e8f28 100644
--- a/Editor/Emit/GroupByModuleEntityManager.cs
+++ b/Editor/Emit/GroupByModuleEntityManager.cs
@@ -6,14 +6,35 @@ namespace Obfuz.Emit
 {
     public interface IGroupByModuleEntity
     {
-        void Init(ModuleDef mod);
+        GroupByModuleEntityManager Manager { get; set; }
+
+        ModuleDef Module { get; set; }
+
+        public EncryptionScopeProvider EncryptionScopeProvider { get; }
+
+        EncryptionScopeInfo EncryptionScope { get; set; }
+
+        void Init();
 
         void Done();
     }
 
     public abstract class GroupByModuleEntityBase : IGroupByModuleEntity
     {
-        public abstract void Init(ModuleDef mod);
+        public GroupByModuleEntityManager Manager { get; set; }
+
+        public ModuleDef Module { get; set; }
+
+        public EncryptionScopeInfo EncryptionScope { get; set; }
+
+        public EncryptionScopeProvider EncryptionScopeProvider => Manager.EncryptionScopeProvider;
+
+        public T GetEntity<T>() where T : IGroupByModuleEntity, new()
+        {
+            return Manager.GetEntity<T>(Module);
+        }
+
+        public abstract void Init();
 
         public abstract void Done();
     }
@@ -22,7 +43,9 @@ namespace Obfuz.Emit
     {
         private readonly Dictionary<(ModuleDef, Type), IGroupByModuleEntity> _moduleEntityManagers = new Dictionary<(ModuleDef, Type), IGroupByModuleEntity>();
 
-        public T GetEntity<T>(ModuleDef mod, Func<T> creator = null) where T : IGroupByModuleEntity
+        public EncryptionScopeProvider EncryptionScopeProvider { get; set; }
+
+        public T GetEntity<T>(ModuleDef mod) where T : IGroupByModuleEntity, new()
         {
             var key = (mod, typeof(T));
             if (_moduleEntityManagers.TryGetValue(key, out var emitManager))
@@ -31,22 +54,17 @@ namespace Obfuz.Emit
             }
             else
             {
-                T newEmitManager;
-                if (creator != null)
-                {
-                    newEmitManager = creator();
-                }
-                else
-                {
-                    newEmitManager = (T)Activator.CreateInstance(typeof(T));
-                }
-                newEmitManager.Init(mod);
+                T newEmitManager = new T();
+                newEmitManager.Manager = this;
+                newEmitManager.Module = mod;
+                newEmitManager.EncryptionScope = EncryptionScopeProvider.GetScope(mod);
+                newEmitManager.Init();
                 _moduleEntityManagers[key] = newEmitManager;
                 return newEmitManager;
             }
         }
 
-        public List<T> GetEntities<T>() where T : IGroupByModuleEntity
+        public List<T> GetEntities<T>() where T : IGroupByModuleEntity, new()
         {
             var managers = new List<T>();
             foreach (var kv in _moduleEntityManagers)
@@ -59,19 +77,13 @@ namespace Obfuz.Emit
             return managers;
         }
 
-        public void Done<T>() where T : IGroupByModuleEntity
+        public void Done<T>() where T : IGroupByModuleEntity, new()
         {
             var managers = GetEntities<T>();
             foreach (var manager in managers)
             {
                 manager.Done();
             }
-            _moduleEntityManagers.Remove((default(ModuleDef), typeof(T)));
-        }
-
-        public DefaultMetadataImporter GetDefaultModuleMetadataImporter(ModuleDef module, EncryptionScopeProvider encryptionScopeProvider)
-        {
-            return GetEntity<DefaultMetadataImporter>(module, () => new DefaultMetadataImporter(encryptionScopeProvider));
         }
     }
 }
diff --git a/Editor/ObfusPasses/CallObfus/CallObfusPass.cs b/Editor/ObfusPasses/CallObfus/CallObfusPass.cs
index 68721bf..6a099f9 100644
--- a/Editor/ObfusPasses/CallObfus/CallObfusPass.cs
+++ b/Editor/ObfusPasses/CallObfus/CallObfusPass.cs
@@ -17,6 +17,8 @@ namespace Obfuz.ObfusPasses.CallObfus
 
     public class CallObfusPass : ObfuscationMethodPassBase
     {
+        public static CallObfuscationSettingsFacade CurrentSettings { get; private set; }
+
         private readonly CallObfuscationSettingsFacade _settings;
         private readonly SpecialWhiteListMethodCalculator _specialWhiteListMethodCache;
 
@@ -28,6 +30,8 @@ namespace Obfuz.ObfusPasses.CallObfus
         public CallObfusPass(CallObfuscationSettingsFacade settings)
         {
             _settings = settings;
+            CurrentSettings = settings;
+
             _specialWhiteListMethodCache = new SpecialWhiteListMethodCalculator(settings.obfuscateCallToMethodInMscorlib);
         }
 
@@ -48,9 +52,9 @@ namespace Obfuz.ObfusPasses.CallObfus
             switch (mode)
             {
                 case ProxyMode.Dispatch:
-                return new DispatchProxyObfuscator(ctx.encryptionScopeProvider, ctx.constFieldAllocator, ctx.moduleEntityManager, _settings);
+                    return new DispatchProxyObfuscator(ctx.moduleEntityManager);
                 case ProxyMode.Delegate:
-                    return new DelegateProxyObfuscator(ctx.encryptionScopeProvider, ctx.moduleEntityManager, ctx.rvaDataAllocator, _settings);
+                    return new DelegateProxyObfuscator(ctx.moduleEntityManager);
                 default:
                 throw new System.NotSupportedException($"Unsupported proxy mode: {mode}");
             }
@@ -66,7 +70,7 @@ namespace Obfuz.ObfusPasses.CallObfus
             var totalFinalInstructions = new List<Instruction>();
 
             ObfuscationPassContext ctx = ObfuscationPassContext.Current;
-            var encryptionScope = ctx.encryptionScopeProvider.GetScope(method.Module);
+            var encryptionScope = ctx.moduleEntityManager.EncryptionScopeProvider.GetScope(method.Module);
             var localRandom = encryptionScope.localRandomCreator(MethodEqualityComparer.CompareDeclaringTypes.GetHashCode(method));
             var omc = new ObfusMethodContext
             {
diff --git a/Editor/ObfusPasses/CallObfus/DelegateProxyAllocator.cs b/Editor/ObfusPasses/CallObfus/DelegateProxyAllocator.cs
index b0255fc..d96dce1 100644
--- a/Editor/ObfusPasses/CallObfus/DelegateProxyAllocator.cs
+++ b/Editor/ObfusPasses/CallObfus/DelegateProxyAllocator.cs
@@ -24,17 +24,11 @@ namespace Obfuz.ObfusPasses.CallObfus
         }
     }
 
-    class ModuleDelegateProxyAllocator : IGroupByModuleEntity
+    class DelegateProxyAllocator : GroupByModuleEntityBase
     {
-        private readonly GroupByModuleEntityManager _moduleEntityManager;
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private readonly RvaDataAllocator _rvaDataAllocator;
-        private readonly CallObfuscationSettingsFacade _settings;
         private readonly CachedDictionary<MethodSig, TypeDef> _delegateTypes;
         private readonly HashSet<string> _allocatedDelegateNames = new HashSet<string>();
 
-        private ModuleDef _module;
-
         private TypeDef _delegateInstanceHolderType;
         private bool _done;
 
@@ -53,19 +47,13 @@ namespace Obfuz.ObfusPasses.CallObfus
         }
         private readonly Dictionary<MethodKey, CallInfo> _callMethods = new Dictionary<MethodKey, CallInfo>();
 
-        public ModuleDelegateProxyAllocator(GroupByModuleEntityManager moduleEntityManager, EncryptionScopeProvider encryptionScopeProvider, RvaDataAllocator rvaDataAllocator, CallObfuscationSettingsFacade settings)
+        public DelegateProxyAllocator()
         {
-            _moduleEntityManager = moduleEntityManager;
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _rvaDataAllocator = rvaDataAllocator;
-            _settings = settings;
             _delegateTypes = new CachedDictionary<MethodSig, TypeDef>(SignatureEqualityComparer.Instance, CreateDelegateForSignature);
         }
 
-        public void Init(ModuleDef mod)
+        public override void Init()
         {
-            _module = mod;
-
             _delegateInstanceHolderType = CreateDelegateInstanceHolderTypeDef();
         }
 
@@ -89,19 +77,20 @@ namespace Obfuz.ObfusPasses.CallObfus
 
         private TypeDef CreateDelegateForSignature(MethodSig delegateInvokeSig)
         {
-            using (var scope = new DisableTypeDefFindCacheScope(_module))
+            ModuleDef mod = Module;
+            using (var scope = new DisableTypeDefFindCacheScope(mod))
             {
 
                 string typeName = AllocateDelegateTypeName(delegateInvokeSig);
-                _module.Import(typeof(MulticastDelegate));
+                mod.Import(typeof(MulticastDelegate));
 
-                TypeDef delegateType = new TypeDefUser("", typeName, _module.CorLibTypes.GetTypeRef("System", "MulticastDelegate"));
+                TypeDef delegateType = new TypeDefUser("", typeName, mod.CorLibTypes.GetTypeRef("System", "MulticastDelegate"));
                 delegateType.Attributes = TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public;
-                _module.Types.Add(delegateType);
+                mod.Types.Add(delegateType);
 
                 MethodDef ctor = new MethodDefUser(
                     ".ctor",
-                    MethodSig.CreateInstance(_module.CorLibTypes.Void, _module.CorLibTypes.Object, _module.CorLibTypes.IntPtr),
+                    MethodSig.CreateInstance(mod.CorLibTypes.Void, mod.CorLibTypes.Object, mod.CorLibTypes.IntPtr),
                     MethodImplAttributes.Runtime,
                     MethodAttributes.RTSpecialName | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public
                 );
@@ -121,12 +110,13 @@ namespace Obfuz.ObfusPasses.CallObfus
 
         private TypeDef CreateDelegateInstanceHolderTypeDef()
         {
-            using (var scope = new DisableTypeDefFindCacheScope(_module))
+            ModuleDef mod = Module;
+            using (var scope = new DisableTypeDefFindCacheScope(mod))
             {
                 string typeName = "$Obfuz$DelegateInstanceHolder";
-                TypeDef holderType = new TypeDefUser("", typeName, _module.CorLibTypes.Object.ToTypeDefOrRef());
+                TypeDef holderType = new TypeDefUser("", typeName, mod.CorLibTypes.Object.ToTypeDefOrRef());
                 holderType.Attributes = TypeAttributes.Class | TypeAttributes.Public;
-                _module.Types.Add(holderType);
+                mod.Types.Add(holderType);
                 return holderType;
             }
         }
@@ -192,7 +182,7 @@ namespace Obfuz.ObfusPasses.CallObfus
             return new DelegateProxyMethodData(callInfo.delegateInstanceField, callInfo.delegateInvokeMethod);
         }
 
-        public void Done()
+        public override void Done()
         {
             if (_done)
             {
@@ -200,12 +190,14 @@ namespace Obfuz.ObfusPasses.CallObfus
             }
             _done = true;
 
+            ModuleDef mod = Module;
+
             // for stable order, we sort methods by name
             List<CallInfo> callMethodList = _callMethods.Values.ToList();
             callMethodList.Sort((a, b) => a.key1.CompareTo(b.key1));
 
             var cctor = new MethodDefUser(".cctor",
-                MethodSig.CreateStatic(_module.CorLibTypes.Void),
+                MethodSig.CreateStatic(mod.CorLibTypes.Void),
                 MethodImplAttributes.IL | MethodImplAttributes.Managed,
                 MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.Private);
             cctor.DeclaringType = _delegateInstanceHolderType;
@@ -219,7 +211,7 @@ namespace Obfuz.ObfusPasses.CallObfus
             // arr[index] = d;
             int index = 0;
             ins.Add(Instruction.CreateLdcI4(callMethodList.Count));
-            ins.Add(Instruction.Create(OpCodes.Newarr, _module.CorLibTypes.Object));
+            ins.Add(Instruction.Create(OpCodes.Newarr, mod.CorLibTypes.Object));
             foreach (CallInfo ci in callMethodList)
             {
                 ci.index = index;
@@ -240,8 +232,9 @@ namespace Obfuz.ObfusPasses.CallObfus
             List<CallInfo> callMethodList2 = callMethodList.ToList();
             callMethodList2.Sort((a, b) => a.key2.CompareTo(b.key2));
 
-            EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(_module);
-            DefaultMetadataImporter importer = _moduleEntityManager.GetDefaultModuleMetadataImporter(_module, _encryptionScopeProvider);
+            EncryptionScopeInfo encryptionScope = EncryptionScope;
+            DefaultMetadataImporter importer = this.GetDefaultModuleMetadataImporter();
+            RvaDataAllocator rvaDataAllocator = this.GetEntity<RvaDataAllocator>();
             foreach (CallInfo ci in callMethodList2)
             {
                 _delegateInstanceHolderType.Fields.Add(ci.delegateInstanceField);
@@ -254,7 +247,7 @@ namespace Obfuz.ObfusPasses.CallObfus
                 int salt = localRandom.NextInt();
 
                 int encryptedValue = encryptionScope.encryptor.Encrypt(ci.index, ops, salt);
-                RvaData rvaData = _rvaDataAllocator.Allocate(_module, encryptedValue);
+                RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
                 ins.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
                 ins.Add(Instruction.CreateLdcI4(rvaData.offset));
                 ins.Add(Instruction.CreateLdcI4(ops));
@@ -268,33 +261,4 @@ namespace Obfuz.ObfusPasses.CallObfus
             ins.Add(Instruction.Create(OpCodes.Ret));
         }
     }
-
-    class DelegateProxyAllocator
-    {
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private readonly GroupByModuleEntityManager _moduleEntityManager;
-        private readonly CallObfuscationSettingsFacade _settings;
-        private readonly RvaDataAllocator _rvaDataAllocator;
-
-        public DelegateProxyAllocator(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager, RvaDataAllocator rvaDataAllocator, CallObfuscationSettingsFacade settings)
-        {
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _moduleEntityManager = moduleEntityManager;
-            _rvaDataAllocator = rvaDataAllocator;
-            _settings = settings;
-        }
-
-        public ModuleDelegateProxyAllocator GetModuleAllocator(ModuleDef mod)
-        {
-            return _moduleEntityManager.GetEntity<ModuleDelegateProxyAllocator>(mod, () => new ModuleDelegateProxyAllocator(_moduleEntityManager, _encryptionScopeProvider, _rvaDataAllocator, _settings));
-        }
-
-        public void Done()
-        {
-            foreach (var allocator in _moduleEntityManager.GetEntities<ModuleDelegateProxyAllocator>())
-            {
-                allocator.Done();
-            }
-        }
-    }
 }
diff --git a/Editor/ObfusPasses/CallObfus/DelegateProxyObfuscator.cs b/Editor/ObfusPasses/CallObfus/DelegateProxyObfuscator.cs
index b736dc1..bc6ce18 100644
--- a/Editor/ObfusPasses/CallObfus/DelegateProxyObfuscator.cs
+++ b/Editor/ObfusPasses/CallObfus/DelegateProxyObfuscator.cs
@@ -12,16 +12,16 @@ namespace Obfuz.ObfusPasses.CallObfus
 
     public class DelegateProxyObfuscator : ObfuscatorBase
     {
-        private readonly DelegateProxyAllocator _delegateProxyAllocator;
+        private readonly GroupByModuleEntityManager _entityManager;
 
-        public DelegateProxyObfuscator(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager, RvaDataAllocator rvaDataAllocator, CallObfuscationSettingsFacade settings)
+        public DelegateProxyObfuscator(GroupByModuleEntityManager moduleEntityManager)
         {
-            _delegateProxyAllocator = new DelegateProxyAllocator(encryptionScopeProvider, moduleEntityManager, rvaDataAllocator, settings);
+            _entityManager = moduleEntityManager;
         }
 
         public override void Done()
         {
-            _delegateProxyAllocator.Done();
+            _entityManager.Done<DelegateProxyAllocator>();
         }
 
         private MethodSig CreateProxyMethodSig(ModuleDef module, IMethod method)
@@ -47,7 +47,7 @@ namespace Obfuz.ObfusPasses.CallObfus
 
         public override bool Obfuscate(MethodDef callingMethod, IMethod calledMethod, bool callVir, List<Instruction> obfuscatedInstructions)
         {
-            ModuleDelegateProxyAllocator allocator = _delegateProxyAllocator.GetModuleAllocator(callingMethod.Module);
+            DelegateProxyAllocator allocator = _entityManager.GetEntity<DelegateProxyAllocator>(callingMethod.Module);
             LocalVariableAllocator localVarAllocator = new LocalVariableAllocator(callingMethod);
             MethodSig methodSig = CreateProxyMethodSig(callingMethod.Module, calledMethod);
             DelegateProxyMethodData proxyData = allocator.Allocate(calledMethod, callVir, methodSig);
diff --git a/Editor/ObfusPasses/CallObfus/DispatchProxyAllocator.cs b/Editor/ObfusPasses/CallObfus/DispatchProxyAllocator.cs
index 8ebfca9..f4fe3bc 100644
--- a/Editor/ObfusPasses/CallObfus/DispatchProxyAllocator.cs
+++ b/Editor/ObfusPasses/CallObfus/DispatchProxyAllocator.cs
@@ -31,14 +31,10 @@ namespace Obfuz.ObfusPasses.CallObfus
         }
     }
 
-    class ModuleDispatchProxyAllocator : IGroupByModuleEntity
+    class ModuleDispatchProxyAllocator : GroupByModuleEntityBase
     {
-        private ModuleDef _module;
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private readonly CallObfuscationSettingsFacade _settings;
-
-        private EncryptionScopeInfo _encryptionScope;
         private bool _done;
+        private CallObfuscationSettingsFacade _settings;
 
 
         class MethodProxyInfo
@@ -71,25 +67,23 @@ namespace Obfuz.ObfusPasses.CallObfus
 
         private TypeDef _proxyTypeDef;
 
-        public ModuleDispatchProxyAllocator(EncryptionScopeProvider encryptionScopeProvider, CallObfuscationSettingsFacade settings)
+        public ModuleDispatchProxyAllocator()
         {
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _settings = settings;
         }
 
-        public void Init(ModuleDef mod)
+        public override void Init()
         {
-            _module = mod;
-            _encryptionScope = _encryptionScopeProvider.GetScope(mod);
+            _settings = CallObfusPass.CurrentSettings;
         }
 
         private TypeDef CreateProxyTypeDef()
         {
-            using (var scope = new DisableTypeDefFindCacheScope(_module))
+            ModuleDef mod = Module;
+            using (var scope = new DisableTypeDefFindCacheScope(mod))
             {
-                var typeDef = new TypeDefUser($"{ConstValues.ObfuzInternalSymbolNamePrefix}ProxyCall", _module.CorLibTypes.Object.ToTypeDefOrRef());
+                var typeDef = new TypeDefUser($"{ConstValues.ObfuzInternalSymbolNamePrefix}ProxyCall", mod.CorLibTypes.Object.ToTypeDefOrRef());
                 typeDef.Attributes = TypeAttributes.NotPublic | TypeAttributes.Sealed;
-                _module.Types.Add(typeDef);
+                mod.Types.Add(typeDef);
                 return typeDef;
             }
         }
@@ -135,24 +129,25 @@ namespace Obfuz.ObfusPasses.CallObfus
 
         private MethodSig CreateDispatchMethodSig(IMethod method)
         {
-            MethodSig methodSig = MetaUtil.ToSharedMethodSig(_module.CorLibTypes, MetaUtil.GetInflatedMethodSig(method, null));
+            ModuleDef mod = Module;
+            MethodSig methodSig = MetaUtil.ToSharedMethodSig(mod.CorLibTypes, MetaUtil.GetInflatedMethodSig(method, null));
             //MethodSig methodSig = MetaUtil.GetInflatedMethodSig(method).Clone();
             //methodSig.Params
             switch (MetaUtil.GetThisArgType(method))
             {
                 case ThisArgType.Class:
                 {
-                    methodSig.Params.Insert(0, _module.CorLibTypes.Object);
+                    methodSig.Params.Insert(0, mod.CorLibTypes.Object);
                     break;
                 }
                 case ThisArgType.ValueType:
                 {
-                    methodSig.Params.Insert(0, _module.CorLibTypes.IntPtr);
+                    methodSig.Params.Insert(0, mod.CorLibTypes.IntPtr);
                     break;
                 }
             }
             // extra param for index
-            methodSig.Params.Add(_module.CorLibTypes.Int32);
+            methodSig.Params.Add(mod.CorLibTypes.Int32);
             return MethodSig.CreateStatic(methodSig.RetType, methodSig.Params.ToArray());
         }
 
@@ -163,7 +158,7 @@ namespace Obfuz.ObfusPasses.CallObfus
 
         private int GenerateEncryptOps(IRandom random)
         {
-            return EncryptionUtil.GenerateEncryptionOpCodes(random, _encryptionScope.encryptor, _settings.obfuscationLevel);
+            return EncryptionUtil.GenerateEncryptionOpCodes(random, EncryptionScope.encryptor, _settings.obfuscationLevel);
         }
 
         private DispatchMethodInfo GetDispatchMethod(IMethod method)
@@ -188,7 +183,7 @@ namespace Obfuz.ObfusPasses.CallObfus
         private IRandom CreateRandomForMethod(IMethod method, bool callVir)
         {
             int seed = MethodEqualityComparer.CompareDeclaringTypes.GetHashCode(method);
-            return _encryptionScope.localRandomCreator(seed);
+            return EncryptionScope.localRandomCreator(seed);
         }
 
         public ProxyCallMethodData Allocate(IMethod method, bool callVir)
@@ -206,7 +201,7 @@ namespace Obfuz.ObfusPasses.CallObfus
                 IRandom localRandom = CreateRandomForMethod(method, callVir);
                 int encryptOps = GenerateEncryptOps(localRandom);
                 int salt = GenerateSalt(localRandom);
-                int encryptedIndex = _encryptionScope.encryptor.Encrypt(index, encryptOps, salt);
+                int encryptedIndex = EncryptionScope.encryptor.Encrypt(index, encryptOps, salt);
                 proxyInfo = new MethodProxyInfo()
                 {
                     proxyMethod = methodDispatcher.methodDef,
@@ -221,7 +216,7 @@ namespace Obfuz.ObfusPasses.CallObfus
             return new ProxyCallMethodData(proxyInfo.proxyMethod, proxyInfo.encryptedOps, proxyInfo.salt, proxyInfo.encryptedIndex, proxyInfo.index);
         }
 
-        public void Done()
+        public override void Done()
         {
             if (_done)
             {
@@ -275,37 +270,4 @@ namespace Obfuz.ObfusPasses.CallObfus
             }
         }
     }
-
-    public class DispatchProxyAllocator
-    {
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private GroupByModuleEntityManager _moduleEntityManager;
-        private readonly CallObfuscationSettingsFacade _settings;
-
-        public DispatchProxyAllocator(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager, CallObfuscationSettingsFacade settings)
-        {
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _moduleEntityManager = moduleEntityManager;
-            _settings = settings;
-        }
-
-        private ModuleDispatchProxyAllocator GetModuleAllocator(ModuleDef mod)
-        {
-            return _moduleEntityManager.GetEntity<ModuleDispatchProxyAllocator>(mod, () => new ModuleDispatchProxyAllocator(_encryptionScopeProvider, _settings));
-        }
-
-        public ProxyCallMethodData Allocate(ModuleDef mod, IMethod method, bool callVir)
-        {
-            ModuleDispatchProxyAllocator allocator = GetModuleAllocator(mod);
-            return allocator.Allocate(method, callVir);
-        }
-
-        public void Done()
-        {
-            foreach (var allocator in _moduleEntityManager.GetEntities<ModuleDispatchProxyAllocator>())
-            {
-                allocator.Done();
-            }
-        }
-    }
 }
diff --git a/Editor/ObfusPasses/CallObfus/DispatchProxyObfuscator.cs b/Editor/ObfusPasses/CallObfus/DispatchProxyObfuscator.cs
index 27bccff..bc54a77 100644
--- a/Editor/ObfusPasses/CallObfus/DispatchProxyObfuscator.cs
+++ b/Editor/ObfusPasses/CallObfus/DispatchProxyObfuscator.cs
@@ -11,30 +11,24 @@ namespace Obfuz.ObfusPasses.CallObfus
 
     public class DispatchProxyObfuscator : ObfuscatorBase
     {
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private readonly ConstFieldAllocator _constFieldAllocator;
-        private readonly DispatchProxyAllocator _proxyCallAllocator;
         private readonly GroupByModuleEntityManager _moduleEntityManager;
 
-        public DispatchProxyObfuscator(EncryptionScopeProvider encryptionScopeProvider, ConstFieldAllocator constFieldAllocator, GroupByModuleEntityManager moduleEntityManager, CallObfuscationSettingsFacade settings)
+        public DispatchProxyObfuscator(GroupByModuleEntityManager moduleEntityManager)
         {
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _constFieldAllocator = constFieldAllocator;
             _moduleEntityManager = moduleEntityManager;
-            _proxyCallAllocator = new DispatchProxyAllocator(encryptionScopeProvider, moduleEntityManager, settings);
         }
 
         public override void Done()
         {
-            _proxyCallAllocator.Done();
+            _moduleEntityManager.Done<ModuleDispatchProxyAllocator>();
         }
 
         public override bool Obfuscate(MethodDef callerMethod, IMethod calledMethod, bool callVir, List<Instruction> obfuscatedInstructions)
         {
-
+            ModuleDispatchProxyAllocator proxyCallAllocator = _moduleEntityManager.GetEntity<ModuleDispatchProxyAllocator>(callerMethod.Module);
             MethodSig sharedMethodSig = MetaUtil.ToSharedMethodSig(calledMethod.Module.CorLibTypes, MetaUtil.GetInflatedMethodSig(calledMethod, null));
-            ProxyCallMethodData proxyCallMethodData = _proxyCallAllocator.Allocate(callerMethod.Module, calledMethod, callVir);
-            DefaultMetadataImporter importer = _moduleEntityManager.GetDefaultModuleMetadataImporter(callerMethod.Module, _encryptionScopeProvider);
+            ProxyCallMethodData proxyCallMethodData = proxyCallAllocator.Allocate(calledMethod, callVir);
+            DefaultMetadataImporter importer = proxyCallAllocator.GetDefaultModuleMetadataImporter();
 
             //if (needCacheCall)
             //{
@@ -49,7 +43,8 @@ namespace Obfuz.ObfusPasses.CallObfus
             //    obfuscatedInstructions.Add(Instruction.Create(OpCodes.Call, importer.DecryptInt));
             //}
 
-            FieldDef cacheField = _constFieldAllocator.Allocate(callerMethod.Module, proxyCallMethodData.index);
+            ConstFieldAllocator constFieldAllocator = proxyCallAllocator.GetEntity<ConstFieldAllocator>();
+            FieldDef cacheField = constFieldAllocator.Allocate(proxyCallMethodData.index);
             obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, cacheField));
             obfuscatedInstructions.Add(Instruction.Create(OpCodes.Call, proxyCallMethodData.proxyMethod));
             return true;
diff --git a/Editor/ObfusPasses/ConstEncrypt/ConstEncryptPass.cs b/Editor/ObfusPasses/ConstEncrypt/ConstEncryptPass.cs
index b1058bb..896e08a 100644
--- a/Editor/ObfusPasses/ConstEncrypt/ConstEncryptPass.cs
+++ b/Editor/ObfusPasses/ConstEncrypt/ConstEncryptPass.cs
@@ -23,7 +23,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
         {
             var ctx = ObfuscationPassContext.Current;
             _dataObfuscatorPolicy = new ConfigurableEncryptPolicy(ctx.coreSettings.assembliesToObfuscate, _settings.ruleFiles);
-            _dataObfuscator = new DefaultConstEncryptor(ctx.encryptionScopeProvider, ctx.rvaDataAllocator, ctx.constFieldAllocator, ctx.moduleEntityManager, _settings);
+            _dataObfuscator = new DefaultConstEncryptor(ctx.moduleEntityManager, _settings);
         }
 
         public override void Stop()
diff --git a/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs b/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs
index 2115fa2..917d114 100644
--- a/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs
+++ b/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs
@@ -12,17 +12,11 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
 {
     public class DefaultConstEncryptor : IConstEncryptor
     {
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
-        private readonly RvaDataAllocator _rvaDataAllocator;
-        private readonly ConstFieldAllocator _constFieldAllocator;
         private readonly GroupByModuleEntityManager _moduleEntityManager;
         private readonly ConstEncryptionSettingsFacade _settings;
 
-        public DefaultConstEncryptor(EncryptionScopeProvider encryptionScopeProvider, RvaDataAllocator rvaDataAllocator, ConstFieldAllocator constFieldAllocator, GroupByModuleEntityManager moduleEntityManager, ConstEncryptionSettingsFacade settings)
+        public DefaultConstEncryptor(GroupByModuleEntityManager moduleEntityManager, ConstEncryptionSettingsFacade settings)
         {
-            _encryptionScopeProvider = encryptionScopeProvider;
-            _rvaDataAllocator = rvaDataAllocator;
-            _constFieldAllocator = constFieldAllocator;
             _moduleEntityManager = moduleEntityManager;
             _settings = settings;
         }
@@ -44,20 +38,23 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
 
         private DefaultMetadataImporter GetModuleMetadataImporter(MethodDef method)
         {
-            return _moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module, _encryptionScopeProvider);
+            return _moduleEntityManager.GetEntity<DefaultMetadataImporter>(method.Module);
         }
 
         public void ObfuscateInt(MethodDef method, bool needCacheValue, int value, List<Instruction> obfuscatedInstructions)
         {
-            EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
+            EncryptionScopeInfo encryptionScope = _moduleEntityManager.EncryptionScopeProvider.GetScope(method.Module);
             IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
-            ModuleConstFieldAllocator moduleConstFieldAllocator = _constFieldAllocator.GetModuleAllocator(method.Module);
+            ConstFieldAllocator constFieldAllocator = _moduleEntityManager.GetEntity<ConstFieldAllocator>(method.Module);
+            RvaDataAllocator rvaDataAllocator = _moduleEntityManager.GetEntity<RvaDataAllocator>(method.Module);
+            DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
+
             switch (random.NextInt(5))
             {
                 case 0:
                 {
                     // = c = encrypted static field
-                    FieldDef cacheField = _constFieldAllocator.Allocate(method.Module, value);
+                    FieldDef cacheField = constFieldAllocator.Allocate(value);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, cacheField));
                     break;
                 }
@@ -67,7 +64,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                     int a = random.NextInt();
                     int b = value - a;
                     float constProbability = 0.5f;
-                    ConstObfusUtil.LoadConstTwoInt(a, b, random, constProbability, moduleConstFieldAllocator, obfuscatedInstructions);
+                    ConstObfusUtil.LoadConstTwoInt(a, b, random, constProbability, constFieldAllocator, obfuscatedInstructions);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Add));
                     break;
                 }
@@ -78,7 +75,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                     int ra = MathUtil.ModInverse32(a);
                     int b = ra * value;
                     float constProbability = 0.5f;
-                    ConstObfusUtil.LoadConstTwoInt(a, b, random, constProbability, moduleConstFieldAllocator, obfuscatedInstructions);
+                    ConstObfusUtil.LoadConstTwoInt(a, b, random, constProbability, constFieldAllocator, obfuscatedInstructions);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Mul));
                     break;
                 }
@@ -88,7 +85,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                     int a = random.NextInt();
                     int b = a ^ value;
                     float constProbability = 0.5f;
-                    ConstObfusUtil.LoadConstTwoInt(a, b, random, constProbability, moduleConstFieldAllocator, obfuscatedInstructions);
+                    ConstObfusUtil.LoadConstTwoInt(a, b, random, constProbability, constFieldAllocator, obfuscatedInstructions);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Xor));
                     break;
                 }
@@ -96,16 +93,14 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                 {
                     if (needCacheValue)
                     {
-                        FieldDef cacheField = moduleConstFieldAllocator.Allocate(value);
+                        FieldDef cacheField = constFieldAllocator.Allocate(value);
                         obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, cacheField));
                         return;
                     }
                     int ops = GenerateEncryptionOperations(encryptionScope, random);
                     int salt = GenerateSalt(random);
                     int encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
-                    RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);
-
-                    DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
+                    RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
                     obfuscatedInstructions.Add(Instruction.CreateLdcI4(rvaData.offset));
                     obfuscatedInstructions.Add(Instruction.CreateLdcI4(ops));
@@ -120,16 +115,18 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
 
         public void ObfuscateLong(MethodDef method, bool needCacheValue, long value, List<Instruction> obfuscatedInstructions)
         {
-            EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
+            EncryptionScopeInfo encryptionScope = _moduleEntityManager.EncryptionScopeProvider.GetScope(method.Module);
             IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
-            ModuleConstFieldAllocator moduleConstFieldAllocator = _constFieldAllocator.GetModuleAllocator(method.Module);
+            ConstFieldAllocator constFieldAllocator = _moduleEntityManager.GetEntity<ConstFieldAllocator>(method.Module);
+            RvaDataAllocator rvaDataAllocator = _moduleEntityManager.GetEntity<RvaDataAllocator>(method.Module);
+            DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
 
             switch (random.NextInt(5))
             {
                 case 0:
                 {
                     // c = encrypted static field
-                    FieldDef cacheField = _constFieldAllocator.Allocate(method.Module, value);
+                    FieldDef cacheField = constFieldAllocator.Allocate(value);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, cacheField));
                     break;
                 }
@@ -139,7 +136,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                     long a = random.NextLong();
                     long b = value - a;
                     float constProbability = 0.5f;
-                    ConstObfusUtil.LoadConstTwoLong(a, b, random, constProbability, moduleConstFieldAllocator, obfuscatedInstructions);
+                    ConstObfusUtil.LoadConstTwoLong(a, b, random, constProbability, constFieldAllocator, obfuscatedInstructions);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Add));
                     break;
                 }
@@ -150,7 +147,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                     long ra = MathUtil.ModInverse64(a);
                     long b = ra * value;
                     float constProbability = 0.5f;
-                    ConstObfusUtil.LoadConstTwoLong(a, b, random, constProbability, moduleConstFieldAllocator, obfuscatedInstructions);
+                    ConstObfusUtil.LoadConstTwoLong(a, b, random, constProbability, constFieldAllocator, obfuscatedInstructions);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Mul));
                     break;
                 }
@@ -160,7 +157,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                     long a = random.NextLong();
                     long b = a ^ value;
                     float constProbability = 0.5f;
-                    ConstObfusUtil.LoadConstTwoLong(a, b, random, constProbability, moduleConstFieldAllocator, obfuscatedInstructions);
+                    ConstObfusUtil.LoadConstTwoLong(a, b, random, constProbability, constFieldAllocator, obfuscatedInstructions);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Xor));
                     break;
                 }
@@ -168,7 +165,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                 {
                     if (needCacheValue)
                     {
-                        FieldDef cacheField = _constFieldAllocator.Allocate(method.Module, value);
+                        FieldDef cacheField = constFieldAllocator.Allocate(value);
                         obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, cacheField));
                         return;
                     }
@@ -176,9 +173,8 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                     int ops = GenerateEncryptionOperations(encryptionScope, random);
                     int salt = GenerateSalt(random);
                     long encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
-                    RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);
+                    RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
 
-                    DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
                     obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
                     obfuscatedInstructions.Add(Instruction.CreateLdcI4(rvaData.offset));
                     obfuscatedInstructions.Add(Instruction.CreateLdcI4(ops));
@@ -193,21 +189,25 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
 
         public void ObfuscateFloat(MethodDef method, bool needCacheValue, float value, List<Instruction> obfuscatedInstructions)
         {
+            EncryptionScopeInfo encryptionScope = _moduleEntityManager.EncryptionScopeProvider.GetScope(method.Module);
+            IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
+            ConstFieldAllocator constFieldAllocator = _moduleEntityManager.GetEntity<ConstFieldAllocator>(method.Module);
+            RvaDataAllocator rvaDataAllocator = _moduleEntityManager.GetEntity<RvaDataAllocator>(method.Module);
+            DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
+
             if (needCacheValue)
             {
-                FieldDef cacheField = _constFieldAllocator.Allocate(method.Module, value);
+                FieldDef cacheField = constFieldAllocator.Allocate(value);
                 obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, cacheField));
                 return;
             }
 
-            EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
-            IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
+
             int ops = GenerateEncryptionOperations(encryptionScope, random);
             int salt = GenerateSalt(random);
             float encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
-            RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);
+            RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
 
-            DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
             obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
             obfuscatedInstructions.Add(Instruction.CreateLdcI4(rvaData.offset));
             obfuscatedInstructions.Add(Instruction.CreateLdcI4(ops));
@@ -217,21 +217,25 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
 
         public void ObfuscateDouble(MethodDef method, bool needCacheValue, double value, List<Instruction> obfuscatedInstructions)
         {
+            EncryptionScopeInfo encryptionScope = _moduleEntityManager.EncryptionScopeProvider.GetScope(method.Module);
+            IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
+            ConstFieldAllocator constFieldAllocator = _moduleEntityManager.GetEntity<ConstFieldAllocator>(method.Module);
+            RvaDataAllocator rvaDataAllocator = _moduleEntityManager.GetEntity<RvaDataAllocator>(method.Module);
+            DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
+
             if (needCacheValue)
             {
-                FieldDef cacheField = _constFieldAllocator.Allocate(method.Module, value);
+                FieldDef cacheField = constFieldAllocator.Allocate(value);
                 obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, cacheField));
                 return;
             }
 
-            EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
-            IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
+
             int ops = GenerateEncryptionOperations(encryptionScope, random);
             int salt = GenerateSalt(random);
             double encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
-            RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);
+            RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
 
-            DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
             obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
             obfuscatedInstructions.Add(Instruction.CreateLdcI4(rvaData.offset));
             obfuscatedInstructions.Add(Instruction.CreateLdcI4(ops));
@@ -264,7 +268,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
         {
             if (!_encryptedRvaFields.TryGetValue(fieldDef, out var encryptedRvaData))
             {
-                EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(fieldDef.Module);
+                EncryptionScopeInfo encryptionScope = _moduleEntityManager.EncryptionScopeProvider.GetScope(fieldDef.Module);
                 IRandom random = CreateRandomForValue(encryptionScope, FieldEqualityComparer.CompareDeclaringTypes.GetHashCode(fieldDef));
                 int ops = GenerateEncryptionOperations(encryptionScope, random);
                 int salt = GenerateSalt(random);
@@ -297,23 +301,26 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
 
         public void ObfuscateString(MethodDef method, bool needCacheValue, string value, List<Instruction> obfuscatedInstructions)
         {
+            EncryptionScopeInfo encryptionScope = _moduleEntityManager.EncryptionScopeProvider.GetScope(method.Module);
+            IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
+            ConstFieldAllocator constFieldAllocator = _moduleEntityManager.GetEntity<ConstFieldAllocator>(method.Module);
+            RvaDataAllocator rvaDataAllocator = _moduleEntityManager.GetEntity<RvaDataAllocator>(method.Module);
+            DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
+
             if (needCacheValue)
             {
-                FieldDef cacheField = _constFieldAllocator.Allocate(method.Module, value);
+                FieldDef cacheField = constFieldAllocator.Allocate(value);
                 obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, cacheField));
                 return;
             }
 
-            EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(method.Module);
-            IRandom random = CreateRandomForValue(encryptionScope, value.GetHashCode());
             int ops = GenerateEncryptionOperations(encryptionScope, random);
             int salt = GenerateSalt(random);
             int stringByteLength = Encoding.UTF8.GetByteCount(value);
             byte[] encryptedValue = encryptionScope.encryptor.Encrypt(value, ops, salt);
             Assert.AreEqual(stringByteLength, encryptedValue.Length);
-            RvaData rvaData = _rvaDataAllocator.Allocate(method.Module, encryptedValue);
+            RvaData rvaData = rvaDataAllocator.Allocate(encryptedValue);
 
-            DefaultMetadataImporter importer = GetModuleMetadataImporter(method);
             obfuscatedInstructions.Add(Instruction.Create(OpCodes.Ldsfld, rvaData.field));
             obfuscatedInstructions.Add(Instruction.CreateLdcI4(rvaData.offset));
             // should use stringByteLength, can't use rvaData.size, because rvaData.size is align to 4, it's not the actual length.
diff --git a/Editor/ObfusPasses/ControlFlowObfus/ControlFlowObfusPass.cs b/Editor/ObfusPasses/ControlFlowObfus/ControlFlowObfusPass.cs
index 9e9a5a8..bcb04e0 100644
--- a/Editor/ObfusPasses/ControlFlowObfus/ControlFlowObfusPass.cs
+++ b/Editor/ObfusPasses/ControlFlowObfus/ControlFlowObfusPass.cs
@@ -13,7 +13,7 @@ namespace Obfuz.ObfusPasses.ControlFlowObfus
         public IRandom localRandom;
         public EncryptionScopeInfo encryptionScope;
         public DefaultMetadataImporter importer;
-        public ModuleConstFieldAllocator constFieldAllocator;
+        public ConstFieldAllocator constFieldAllocator;
         public int minInstructionCountOfBasicBlockToObfuscate;
 
         public IRandom CreateRandom()
@@ -60,7 +60,8 @@ namespace Obfuz.ObfusPasses.ControlFlowObfus
             //Debug.Log($"Obfuscating method: {method.FullName} with EvalStackObfusPass");
 
             ObfuscationPassContext ctx = ObfuscationPassContext.Current;
-            var encryptionScope = ctx.encryptionScopeProvider.GetScope(method.Module);
+            GroupByModuleEntityManager moduleEntityManager = ctx.moduleEntityManager;
+            var encryptionScope = moduleEntityManager.EncryptionScopeProvider.GetScope(method.Module);
             var ruleData = _obfuscationPolicy.GetObfuscationRuleData(method);
             var localRandom = encryptionScope.localRandomCreator(MethodEqualityComparer.CompareDeclaringTypes.GetHashCode(method));
             var obfusMethodCtx = new ObfusMethodContext
@@ -68,9 +69,9 @@ namespace Obfuz.ObfusPasses.ControlFlowObfus
                 method = method,
                 localVariableAllocator = new LocalVariableAllocator(method),
                 encryptionScope = encryptionScope,
-                constFieldAllocator = ctx.constFieldAllocator.GetModuleAllocator(method.Module),
+                constFieldAllocator = moduleEntityManager.GetEntity<ConstFieldAllocator>(method.Module),
                 localRandom = localRandom,
-                importer = ctx.moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module, ctx.encryptionScopeProvider),
+                importer = moduleEntityManager.GetEntity<DefaultMetadataImporter>(method.Module),
                 minInstructionCountOfBasicBlockToObfuscate = _settings.minInstructionCountOfBasicBlockToObfuscate,
             };
             _obfuscator.Obfuscate(method, obfusMethodCtx);
diff --git a/Editor/ObfusPasses/ControlFlowObfus/MethodControlFlowCalculator.cs b/Editor/ObfusPasses/ControlFlowObfus/MethodControlFlowCalculator.cs
index e509f4d..06488c0 100644
--- a/Editor/ObfusPasses/ControlFlowObfus/MethodControlFlowCalculator.cs
+++ b/Editor/ObfusPasses/ControlFlowObfus/MethodControlFlowCalculator.cs
@@ -6,7 +6,6 @@ using Obfuz.Utils;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.ConstrainedExecution;
 using UnityEngine;
 using UnityEngine.Assertions;
 
@@ -155,11 +154,11 @@ namespace Obfuz.ObfusPasses.ControlFlowObfus
 
         private readonly MethodDef _method;
         private readonly IRandom _random;
-        private readonly ModuleConstFieldAllocator _constFieldAllocator;
+        private readonly ConstFieldAllocator _constFieldAllocator;
         private readonly int _minInstructionCountOfBasicBlockToObfuscate;
         private readonly BasicBlockInfo _bbHead;
 
-        public MethodControlFlowCalculator(MethodDef method, IRandom random, ModuleConstFieldAllocator constFieldAllocator, int minInstructionCountOfBasicBlockToObfuscate)
+        public MethodControlFlowCalculator(MethodDef method, IRandom random, ConstFieldAllocator constFieldAllocator, int minInstructionCountOfBasicBlockToObfuscate)
         {
             _method = method;
             _random = random;
diff --git a/Editor/ObfusPasses/EvalStackObfus/EvalStackObfusPass.cs b/Editor/ObfusPasses/EvalStackObfus/EvalStackObfusPass.cs
index 7e28149..27697ad 100644
--- a/Editor/ObfusPasses/EvalStackObfus/EvalStackObfusPass.cs
+++ b/Editor/ObfusPasses/EvalStackObfus/EvalStackObfusPass.cs
@@ -16,7 +16,7 @@ namespace Obfuz.ObfusPasses.EvalStackObfus
         public IRandom localRandom;
         public EncryptionScopeInfo encryptionScope;
         public DefaultMetadataImporter importer;
-        public ModuleConstFieldAllocator constFieldAllocator;
+        public ConstFieldAllocator constFieldAllocator;
         public float obfuscationPercentage;
     }
 
@@ -74,7 +74,9 @@ namespace Obfuz.ObfusPasses.EvalStackObfus
 
             ObfuscationPassContext ctx = ObfuscationPassContext.Current;
             var calc = new EvalStackCalculator(method);
-            var encryptionScope = ctx.encryptionScopeProvider.GetScope(method.Module);
+
+            GroupByModuleEntityManager moduleEntityManager = ctx.moduleEntityManager;
+            var encryptionScope = moduleEntityManager.EncryptionScopeProvider.GetScope(method.Module);
             var ruleData = _obfuscationPolicy.GetObfuscationRuleData(method);
             var localRandom = encryptionScope.localRandomCreator(MethodEqualityComparer.CompareDeclaringTypes.GetHashCode(method));
             var obfusMethodCtx = new ObfusMethodContext
@@ -83,9 +85,9 @@ namespace Obfuz.ObfusPasses.EvalStackObfus
                 evalStackCalculator = calc,
                 localVariableAllocator = new LocalVariableAllocator(method),
                 encryptionScope = encryptionScope,
-                constFieldAllocator = ctx.constFieldAllocator.GetModuleAllocator(method.Module),
+                constFieldAllocator = moduleEntityManager.GetEntity<ConstFieldAllocator>(method.Module),
                 localRandom = localRandom,
-                importer = ctx.moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module, ctx.encryptionScopeProvider),
+                importer = moduleEntityManager.GetEntity<DefaultMetadataImporter>(method.Module),
                 obfuscationPercentage = ruleData.obfuscationPercentage,
             };
             for (int i = 0; i < instructions.Count; i++)
diff --git a/Editor/ObfusPasses/ExprObfus/ExprObfusPass.cs b/Editor/ObfusPasses/ExprObfus/ExprObfusPass.cs
index ac27992..1a540e6 100644
--- a/Editor/ObfusPasses/ExprObfus/ExprObfusPass.cs
+++ b/Editor/ObfusPasses/ExprObfus/ExprObfusPass.cs
@@ -17,7 +17,7 @@ namespace Obfuz.ObfusPasses.ExprObfus
         public IRandom localRandom;
         public EncryptionScopeInfo encryptionScope;
         public DefaultMetadataImporter importer;
-        public ModuleConstFieldAllocator constFieldAllocator;
+        public ConstFieldAllocator constFieldAllocator;
         public float obfuscationPercentage;
     }
 
@@ -120,7 +120,9 @@ namespace Obfuz.ObfusPasses.ExprObfus
 
             ObfuscationPassContext ctx = ObfuscationPassContext.Current;
             var calc = new EvalStackCalculator(method);
-            var encryptionScope = ctx.encryptionScopeProvider.GetScope(method.Module);
+
+            GroupByModuleEntityManager moduleEntityManager = ctx.moduleEntityManager;
+            var encryptionScope = moduleEntityManager.EncryptionScopeProvider.GetScope(method.Module);
             var ruleData = _obfuscationPolicy.GetObfuscationRuleData(method);
             var obfuscator = GetObfuscator(ruleData.obfuscationLevel);
             var obfusMethodCtx = new ObfusMethodContext
@@ -129,9 +131,9 @@ namespace Obfuz.ObfusPasses.ExprObfus
                 evalStackCalculator = calc,
                 localVariableAllocator = new LocalVariableAllocator(method),
                 encryptionScope = encryptionScope,
-                constFieldAllocator = ctx.constFieldAllocator.GetModuleAllocator(method.Module),
+                constFieldAllocator = moduleEntityManager.GetEntity<ConstFieldAllocator>(method.Module),
                 localRandom = encryptionScope.localRandomCreator(MethodEqualityComparer.CompareDeclaringTypes.GetHashCode(method)),
-                importer = ctx.moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module, ctx.encryptionScopeProvider),
+                importer = moduleEntityManager.GetEntity<DefaultMetadataImporter>(method.Module),
                 obfuscationPercentage = ruleData.obfuscationPercentage,
             };
             for (int i = 0; i < instructions.Count; i++)
diff --git a/Editor/ObfusPasses/ExprObfus/Obfuscators/AdvancedObfuscator.cs b/Editor/ObfusPasses/ExprObfus/Obfuscators/AdvancedObfuscator.cs
index bd2f2a1..f055962 100644
--- a/Editor/ObfusPasses/ExprObfus/Obfuscators/AdvancedObfuscator.cs
+++ b/Editor/ObfusPasses/ExprObfus/Obfuscators/AdvancedObfuscator.cs
@@ -11,7 +11,7 @@ namespace Obfuz.ObfusPasses.ExprObfus.Obfuscators
         protected bool GenerateIdentityTransformForArgument(Instruction inst, EvalDataType op, List<Instruction> outputInsts, ObfusMethodContext ctx)
         {
             IRandom random = ctx.localRandom;
-            ModuleConstFieldAllocator constFieldAllocator = ctx.constFieldAllocator;
+            ConstFieldAllocator constFieldAllocator = ctx.constFieldAllocator;
             switch (op)
             {
                 case EvalDataType.Int32:
diff --git a/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs b/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs
index 5785a34..bc8bbe9 100644
--- a/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs
+++ b/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs
@@ -11,22 +11,15 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
 {
     public class DefaultFieldEncryptor : FieldEncryptorBase
     {
-        private readonly EncryptionScopeProvider _encryptionScopeProvider;
         private readonly GroupByModuleEntityManager _moduleEntityManager;
         private readonly FieldEncryptionSettingsFacade _settings;
 
-        public DefaultFieldEncryptor(EncryptionScopeProvider encryptionScopeProvider, GroupByModuleEntityManager moduleEntityManager, FieldEncryptionSettingsFacade settings)
+        public DefaultFieldEncryptor(GroupByModuleEntityManager moduleEntityManager, FieldEncryptionSettingsFacade settings)
         {
-            _encryptionScopeProvider = encryptionScopeProvider;
             _moduleEntityManager = moduleEntityManager;
             _settings = settings;
         }
 
-        private DefaultMetadataImporter GetMetadataImporter(MethodDef method)
-        {
-            return _moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module, _encryptionScopeProvider);
-        }
-
         class FieldEncryptInfo
         {
             public int encryptOps;
@@ -77,7 +70,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
             {
                 return info;
             }
-            EncryptionScopeInfo encryptionScope = _encryptionScopeProvider.GetScope(field.Module);
+            EncryptionScopeInfo encryptionScope = _moduleEntityManager.EncryptionScopeProvider.GetScope(field.Module);
 
             IRandom random = CreateRandomForField(encryptionScope.localRandomCreator, field);
             IEncryptor encryptor = encryptionScope.encryptor;
@@ -99,7 +92,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
 
         public override void Encrypt(MethodDef method, FieldDef field, List<Instruction> outputInstructions, Instruction currentInstruction)
         {
-            DefaultMetadataImporter importer = GetMetadataImporter(method);
+            DefaultMetadataImporter importer = _moduleEntityManager.GetEntity<DefaultMetadataImporter>(method.Module);
             EncryptionServiceMetadataImporter encryptionServiceMetadataImporter = importer.GetEncryptionServiceMetadataImporterOfModule(field.Module);
             FieldEncryptInfo fei = GetFieldEncryptInfo(field);
             if (fei.fieldType == ElementType.I4 || fei.fieldType == ElementType.U4 || fei.fieldType == ElementType.R4)
@@ -154,7 +147,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
         public override void Decrypt(MethodDef method, FieldDef field, List<Instruction> outputInstructions, Instruction currentInstruction)
         {
             outputInstructions.Add(currentInstruction.Clone());
-            DefaultMetadataImporter importer = GetMetadataImporter(method);
+            DefaultMetadataImporter importer = _moduleEntityManager.GetEntity<DefaultMetadataImporter>(method.Module);
             EncryptionServiceMetadataImporter encryptionServiceMetadataImporter = importer.GetEncryptionServiceMetadataImporterOfModule(field.Module);
             FieldEncryptInfo fei = GetFieldEncryptInfo(field);
             if (fei.fieldType == ElementType.I4 || fei.fieldType == ElementType.U4 || fei.fieldType == ElementType.R4)
diff --git a/Editor/ObfusPasses/FieldEncrypt/FieldEncryptPass.cs b/Editor/ObfusPasses/FieldEncrypt/FieldEncryptPass.cs
index 1fa76c8..3f82faf 100644
--- a/Editor/ObfusPasses/FieldEncrypt/FieldEncryptPass.cs
+++ b/Editor/ObfusPasses/FieldEncrypt/FieldEncryptPass.cs
@@ -24,7 +24,7 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
         public override void Start()
         {
             var ctx = ObfuscationPassContext.Current;
-            _memoryEncryptor = new DefaultFieldEncryptor(ctx.encryptionScopeProvider, ctx.moduleEntityManager, _settings);
+            _memoryEncryptor = new DefaultFieldEncryptor(ctx.moduleEntityManager, _settings);
             _encryptionPolicy = new ConfigurableEncryptPolicy(ctx.obfuzIgnoreScopeComputeCache, ctx.coreSettings.assembliesToObfuscate, _settings.ruleFiles);
         }
 
diff --git a/Editor/ObfusPasses/Instinct/InstinctPass.cs b/Editor/ObfusPasses/Instinct/InstinctPass.cs
index 5422671..f7b3275 100644
--- a/Editor/ObfusPasses/Instinct/InstinctPass.cs
+++ b/Editor/ObfusPasses/Instinct/InstinctPass.cs
@@ -1,6 +1,7 @@
 using dnlib.DotNet;
 using dnlib.DotNet.Emit;
 using Obfuz.Editor;
+using Obfuz.Emit;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -89,7 +90,7 @@ namespace Obfuz.ObfusPasses.Instinct
             }
 
             ObfuscationPassContext ctx = ObfuscationPassContext.Current;
-            var importer = ctx.moduleEntityManager.GetDefaultModuleMetadataImporter(callingMethod.Module, ctx.encryptionScopeProvider);
+            var importer = ctx.moduleEntityManager.GetEntity<DefaultMetadataImporter>(callingMethod.Module);
 
             string methodName = methodDef.Name;
             switch (methodName)
diff --git a/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs b/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
index 64772f9..1ceddfa 100644
--- a/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
+++ b/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
@@ -14,7 +14,6 @@ namespace Obfuz.ObfusPasses.SymbolObfus
 {
     public class SymbolRename
     {
-        private readonly bool _debug;
         private readonly bool _useConsistentNamespaceObfuscation;
         private readonly bool _detectReflectionCompatibility;
         private readonly List<string> _obfuscationRuleFiles;
@@ -43,7 +42,6 @@ namespace Obfuz.ObfusPasses.SymbolObfus
 
         public SymbolRename(SymbolObfuscationSettingsFacade settings)
         {
-            _debug = settings.debug;
             _useConsistentNamespaceObfuscation = settings.useConsistentNamespaceObfuscation;
             _detectReflectionCompatibility = settings.detectReflectionCompatibility;
             _mappingXmlPath = settings.symbolMappingFile;
@@ -275,7 +273,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus
 
         private void RenameTypes()
         {
-            Debug.Log("RenameTypes begin");
+            //Debug.Log("RenameTypes begin");
 
             RetargetTypeRefInCustomAttributes();
 
@@ -295,7 +293,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus
 
             // clean cache
             _assemblyCache.EnableTypeDefCache = true;
-            Debug.Log("Rename Types end");
+            //Debug.Log("Rename Types end");
         }
 
 
@@ -398,7 +396,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus
 
         private void RenameFields()
         {
-            Debug.Log("Rename fields begin");
+            //Debug.Log("Rename fields begin");
             var refFieldMetasMap = new Dictionary<FieldDef, RefFieldMetas>();
             BuildRefFieldMetasMap(refFieldMetasMap);
 
@@ -415,7 +413,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus
                     }
                 }
             }
-            Debug.Log("Rename fields end");
+            //Debug.Log("Rename fields end");
         }
 
         class RefMethodMetas
@@ -509,8 +507,8 @@ namespace Obfuz.ObfusPasses.SymbolObfus
 
         private void RenameMethods()
         {
-            Debug.Log("Rename methods begin");
-            Debug.Log("Rename not virtual methods begin");
+            //Debug.Log("Rename methods begin");
+            //Debug.Log("Rename not virtual methods begin");
             var virtualMethods = new List<MethodDef>();
             var refMethodMetasMap = new Dictionary<MethodDef, RefMethodMetas>();
             BuildRefMethodMetasMap(refMethodMetasMap);
@@ -547,10 +545,10 @@ namespace Obfuz.ObfusPasses.SymbolObfus
                 }
             }
 
-            Debug.Log("Rename not virtual methods end");
+            //Debug.Log("Rename not virtual methods end");
 
 
-            Debug.Log("Rename virtual methods begin");
+            //Debug.Log("Rename virtual methods begin");
             var visitedVirtualMethods = new HashSet<MethodDef>();
             var groupNeedRenames = new Dictionary<VirtualMethodGroup, bool>();
             foreach (var method in virtualMethods)
@@ -614,8 +612,8 @@ namespace Obfuz.ObfusPasses.SymbolObfus
                     throw new Exception($"group:{group} method:{method} not found in rename record map");
                 }
             }
-            Debug.Log("Rename virtual methods end");
-            Debug.Log("Rename methods end");
+            //Debug.Log("Rename virtual methods end");
+            //Debug.Log("Rename methods end");
         }
 
         class RefPropertyMetas
@@ -669,7 +667,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus
 
         private void RenameProperties()
         {
-            Debug.Log("Rename properties begin");
+            //Debug.Log("Rename properties begin");
             var refPropertyMetasMap = new Dictionary<PropertyDef, RefPropertyMetas>();
             BuildRefPropertyMetasMap(refPropertyMetasMap);
             foreach (ModuleDef mod in _toObfuscatedModules)
@@ -685,12 +683,12 @@ namespace Obfuz.ObfusPasses.SymbolObfus
                     }
                 }
             }
-            Debug.Log("Rename properties end");
+            //Debug.Log("Rename properties end");
         }
 
         private void RenameEvents()
         {
-            Debug.Log("Rename events begin");
+            //Debug.Log("Rename events begin");
             foreach (ModuleDef mod in _toObfuscatedModules)
             {
                 foreach (TypeDef type in mod.GetTypes())
@@ -704,7 +702,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus
                     }
                 }
             }
-            Debug.Log("Rename events begin");
+            //Debug.Log("Rename events begin");
         }
 
         private void Rename(TypeDef type, RefTypeDefMetas refTypeDefMeta)
diff --git a/Editor/ObfuscationPassContext.cs b/Editor/ObfuscationPassContext.cs
index af4a7bf..7f2f60f 100644
--- a/Editor/ObfuscationPassContext.cs
+++ b/Editor/ObfuscationPassContext.cs
@@ -64,9 +64,6 @@ namespace Obfuz
         public List<ModuleDef> allObfuscationRelativeModules;
         public ObfuzIgnoreScopeComputeCache obfuzIgnoreScopeComputeCache;
 
-        public EncryptionScopeProvider encryptionScopeProvider;
-        public ConstFieldAllocator constFieldAllocator;
-        public RvaDataAllocator rvaDataAllocator;
         public ObfuscationMethodWhitelist whiteList;
         public ConfigurablePassPolicy passPolicy;
     }
diff --git a/Editor/Obfuscator.cs b/Editor/Obfuscator.cs
index b326096..9f4760b 100644
--- a/Editor/Obfuscator.cs
+++ b/Editor/Obfuscator.cs
@@ -283,23 +283,22 @@ namespace Obfuz
             LoadAssemblies(assemblyCache, modulesToObfuscate, allObfuscationRelativeModules);
 
             EncryptionScopeProvider encryptionScopeProvider = CreateEncryptionScopeProvider();
-            var moduleEntityManager = new GroupByModuleEntityManager();
+            var moduleEntityManager = new GroupByModuleEntityManager()
+            {
+                EncryptionScopeProvider = encryptionScopeProvider,
+            };
             var obfuzIgnoreScopeComputeCache = new ObfuzIgnoreScopeComputeCache();
-            var rvaDataAllocator = new RvaDataAllocator(encryptionScopeProvider, moduleEntityManager);
-            var constFieldAllocator = new ConstFieldAllocator(encryptionScopeProvider, rvaDataAllocator, moduleEntityManager);
             _ctx = new ObfuscationPassContext
             {
                 coreSettings = _coreSettings,
                 assemblyCache = assemblyCache,
                 modulesToObfuscate = modulesToObfuscate,
                 allObfuscationRelativeModules = allObfuscationRelativeModules,
+
                 moduleEntityManager = moduleEntityManager,
 
-                encryptionScopeProvider = encryptionScopeProvider,
                 obfuzIgnoreScopeComputeCache = obfuzIgnoreScopeComputeCache,
 
-                rvaDataAllocator = rvaDataAllocator,
-                constFieldAllocator = constFieldAllocator,
                 whiteList = new ObfuscationMethodWhitelist(obfuzIgnoreScopeComputeCache),
                 passPolicy = _passPolicy,
             };
@@ -345,8 +344,8 @@ namespace Obfuz
         {
             pipeline.Stop();
 
-            _ctx.constFieldAllocator.Done();
-            _ctx.rvaDataAllocator.Done();
+            _ctx.moduleEntityManager.Done<ConstFieldAllocator>();
+            _ctx.moduleEntityManager.Done<RvaDataAllocator>();
             WriteAssemblies();
         }
     }
diff --git a/Editor/Utils/ConstObfusUtil.cs b/Editor/Utils/ConstObfusUtil.cs
index 8178e45..67c64d0 100644
--- a/Editor/Utils/ConstObfusUtil.cs
+++ b/Editor/Utils/ConstObfusUtil.cs
@@ -7,7 +7,7 @@ namespace Obfuz.Utils
 {
     internal static class ConstObfusUtil
     {
-        public static void LoadConstInt(int a, IRandom random, float constProbability, ModuleConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
+        public static void LoadConstInt(int a, IRandom random, float constProbability, ConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
         {
             Instruction inst;
             if (random.NextInPercentage(constProbability))
@@ -22,7 +22,7 @@ namespace Obfuz.Utils
             outputInsts.Add(inst);
         }
 
-        public static void LoadConstLong(long a, IRandom random, float constProbability, ModuleConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
+        public static void LoadConstLong(long a, IRandom random, float constProbability, ConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
         {
             Instruction inst;
             if (random.NextInPercentage(constProbability))
@@ -37,7 +37,7 @@ namespace Obfuz.Utils
             outputInsts.Add(inst);
         }
 
-        public static void LoadConstFloat(float a, IRandom random, float constProbability, ModuleConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
+        public static void LoadConstFloat(float a, IRandom random, float constProbability, ConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
         {
             Instruction inst;
             if (random.NextInPercentage(constProbability))
@@ -52,7 +52,7 @@ namespace Obfuz.Utils
             outputInsts.Add(inst);
         }
 
-        public static void LoadConstDouble(double a, IRandom random, float constProbability, ModuleConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
+        public static void LoadConstDouble(double a, IRandom random, float constProbability, ConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
         {
             Instruction inst;
             if (random.NextInPercentage(constProbability))
@@ -68,7 +68,7 @@ namespace Obfuz.Utils
         }
 
 
-        public static void LoadConstTwoInt(int a, int b, IRandom random, float constProbability, ModuleConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
+        public static void LoadConstTwoInt(int a, int b, IRandom random, float constProbability, ConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
         {
             if (random.NextInPercentage(constProbability))
             {
@@ -96,7 +96,7 @@ namespace Obfuz.Utils
             }
         }
 
-        public static void LoadConstTwoLong(long a, long b, IRandom random, float constProbability, ModuleConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
+        public static void LoadConstTwoLong(long a, long b, IRandom random, float constProbability, ConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
         {
             if (random.NextInPercentage(constProbability))
             {
@@ -122,7 +122,7 @@ namespace Obfuz.Utils
             }
         }
 
-        public static void LoadConstTwoFloat(float a, float b, IRandom random, float constProbability, ModuleConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
+        public static void LoadConstTwoFloat(float a, float b, IRandom random, float constProbability, ConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
         {
             if (random.NextInPercentage(constProbability))
             {
@@ -148,7 +148,7 @@ namespace Obfuz.Utils
             }
         }
 
-        public static void LoadConstTwoDouble(double a, double b, IRandom random, float constProbability, ModuleConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
+        public static void LoadConstTwoDouble(double a, double b, IRandom random, float constProbability, ConstFieldAllocator constFieldAllocator, List<Instruction> outputInsts)
         {
             if (random.NextInPercentage(constProbability))
             {