diff --git a/Editor/Data/ConstFieldAllocator.cs b/Editor/Data/ConstFieldAllocator.cs
index 3997f8a..f490195 100644
--- a/Editor/Data/ConstFieldAllocator.cs
+++ b/Editor/Data/ConstFieldAllocator.cs
@@ -18,6 +18,7 @@ namespace Obfuz.Data
         private readonly IRandom _random;
         private readonly IEncryptor _encryptor;
         private readonly RvaDataAllocator _rvaDataAllocator;
+        private readonly GroupByModuleEntityManager _moduleEntityManager;
 
         private TypeDef _holderTypeDef;
 
@@ -32,11 +33,12 @@ namespace Obfuz.Data
         private readonly List<TypeDef> _holderTypeDefs = new List<TypeDef>();
 
 
-        public ModuleConstFieldAllocator(IEncryptor encryptor, IRandom random, RvaDataAllocator rvaDataAllocator)
+        public ModuleConstFieldAllocator(IEncryptor encryptor, IRandom random, RvaDataAllocator rvaDataAllocator, GroupByModuleEntityManager moduleEntityManager)
         {
             _encryptor = encryptor;
             _random = random;
             _rvaDataAllocator = rvaDataAllocator;
+            _moduleEntityManager = moduleEntityManager;
         }
 
         public void Init(ModuleDef mod)
@@ -138,7 +140,7 @@ namespace Obfuz.Data
 
         private DefaultMetadataImporter GetModuleMetadataImporter()
         {
-            return GroupByModuleEntityManager.Ins.GetDefaultModuleMetadataImporter(_module);
+            return _moduleEntityManager.GetDefaultModuleMetadataImporter(_module);
         }
 
         private void CreateCCtorOfRvaTypeDef(TypeDef type)
@@ -258,17 +260,19 @@ namespace Obfuz.Data
         private readonly IEncryptor _encryptor;
         private readonly IRandom _random;
         private readonly RvaDataAllocator _rvaDataAllocator;
+        private readonly GroupByModuleEntityManager _moduleEntityManager;
 
-        public ConstFieldAllocator(IEncryptor encryptor, IRandom random, RvaDataAllocator rvaDataAllocator)
+        public ConstFieldAllocator(IEncryptor encryptor, IRandom random, RvaDataAllocator rvaDataAllocator, GroupByModuleEntityManager moduleEntityManager)
         {
             _encryptor = encryptor;
             _random = random;
             _rvaDataAllocator = rvaDataAllocator;
+            _moduleEntityManager = moduleEntityManager;
         }
 
         private ModuleConstFieldAllocator GetModuleAllocator(ModuleDef mod)
         {
-            return GroupByModuleEntityManager.Ins.GetEntity<ModuleConstFieldAllocator>(mod, () => new ModuleConstFieldAllocator(_encryptor, _random, _rvaDataAllocator));
+            return _moduleEntityManager.GetEntity<ModuleConstFieldAllocator>(mod, () => new ModuleConstFieldAllocator(_encryptor, _random, _rvaDataAllocator, _moduleEntityManager));
         }
 
         public FieldDef Allocate(ModuleDef mod, int value)
@@ -303,7 +307,7 @@ namespace Obfuz.Data
 
         public void Done()
         {
-            foreach (var moduleAllocator in GroupByModuleEntityManager.Ins.GetEntities<ModuleConstFieldAllocator>())
+            foreach (var moduleAllocator in _moduleEntityManager.GetEntities<ModuleConstFieldAllocator>())
             {
                 moduleAllocator.Done();
             }
diff --git a/Editor/Data/RvaDataAllocator.cs b/Editor/Data/RvaDataAllocator.cs
index 1445938..a67b0e7 100644
--- a/Editor/Data/RvaDataAllocator.cs
+++ b/Editor/Data/RvaDataAllocator.cs
@@ -33,6 +33,7 @@ namespace Obfuz.Data
         private ModuleDef _module;
         private readonly IRandom _random;
         private readonly IEncryptor _encryptor;
+        private readonly GroupByModuleEntityManager _moduleEntityManager;
 
         class RvaField
         {
@@ -69,10 +70,11 @@ namespace Obfuz.Data
 
         private readonly Dictionary<int, TypeDef> _dataHolderTypeBySizes = new Dictionary<int, TypeDef>();
 
-        public ModuleRvaDataAllocator(IRandom random, IEncryptor encryptor)
+        public ModuleRvaDataAllocator(IRandom random, IEncryptor encryptor, GroupByModuleEntityManager moduleEntityManager)
         {
             _random = random;
             _encryptor = encryptor;
+            _moduleEntityManager = moduleEntityManager;
         }
 
         public override void Init(ModuleDef mod)
@@ -234,7 +236,7 @@ namespace Obfuz.Data
             cctorMethod.Body = body;
             var ins = body.Instructions;
 
-            DefaultMetadataImporter importer = GroupByModuleEntityManager.Ins.GetDefaultModuleMetadataImporter(mod);
+            DefaultMetadataImporter importer = _moduleEntityManager.GetDefaultModuleMetadataImporter(mod);
             foreach (var field in _rvaFields)
             {
                 // ldc
@@ -287,16 +289,18 @@ namespace Obfuz.Data
 
         private readonly IRandom _random;
         private readonly IEncryptor _encryptor;
+        private readonly GroupByModuleEntityManager _moduleEntityManager;
 
-        public RvaDataAllocator(IRandom random, IEncryptor encryptor)
+        public RvaDataAllocator(IRandom random, IEncryptor encryptor, GroupByModuleEntityManager moduleEntityManager)
         {
             _random = random;
             _encryptor = encryptor;
+            _moduleEntityManager = moduleEntityManager;
         }
 
         private ModuleRvaDataAllocator GetModuleRvaDataAllocator(ModuleDef mod)
         {
-            return GroupByModuleEntityManager.Ins.GetEntity<ModuleRvaDataAllocator>(mod, () => new ModuleRvaDataAllocator(_random, _encryptor));
+            return _moduleEntityManager.GetEntity<ModuleRvaDataAllocator>(mod, () => new ModuleRvaDataAllocator(_random, _encryptor, _moduleEntityManager));
         }
 
         public RvaData Allocate(ModuleDef mod, int value)
@@ -331,7 +335,7 @@ namespace Obfuz.Data
 
         public void Done()
         {
-            foreach (var allocator in GroupByModuleEntityManager.Ins.GetEntities<ModuleRvaDataAllocator>())
+            foreach (var allocator in _moduleEntityManager.GetEntities<ModuleRvaDataAllocator>())
             {
                 allocator.Done();
             }
diff --git a/Editor/Emit/GroupByModuleEntityManager.cs b/Editor/Emit/GroupByModuleEntityManager.cs
index 159bb12..2e85e41 100644
--- a/Editor/Emit/GroupByModuleEntityManager.cs
+++ b/Editor/Emit/GroupByModuleEntityManager.cs
@@ -19,20 +19,12 @@ namespace Obfuz.Emit
 
     public class GroupByModuleEntityManager
     {
-        public static GroupByModuleEntityManager Ins { get; private set; }
-
-
-        private readonly Dictionary<(ModuleDef, Type), IGroupByModuleEntity> _moduleEmitManagers = new Dictionary<(ModuleDef, Type), IGroupByModuleEntity>();
-
-        public static void Reset()
-        {
-            Ins = new GroupByModuleEntityManager();
-        }
+        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
         {
             var key = (mod, typeof(T));
-            if (_moduleEmitManagers.TryGetValue(key, out var emitManager))
+            if (_moduleEntityManagers.TryGetValue(key, out var emitManager))
             {
                 return (T)emitManager;
             }
@@ -48,7 +40,7 @@ namespace Obfuz.Emit
                     newEmitManager = (T)Activator.CreateInstance(typeof(T));
                 }
                 newEmitManager.Init(mod);
-                _moduleEmitManagers[key] = newEmitManager;
+                _moduleEntityManagers[key] = newEmitManager;
                 return newEmitManager;
             }
         }
@@ -56,7 +48,7 @@ namespace Obfuz.Emit
         public List<T> GetEntities<T>()  where T: IGroupByModuleEntity
         {
             var managers = new List<T>();
-            foreach (var kv in _moduleEmitManagers)
+            foreach (var kv in _moduleEntityManagers)
             {
                 if (kv.Key.Item2 == typeof(T))
                 {
diff --git a/Editor/IObfuscationPass.cs b/Editor/IObfuscationPass.cs
index 230c08b..16d875f 100644
--- a/Editor/IObfuscationPass.cs
+++ b/Editor/IObfuscationPass.cs
@@ -11,10 +11,10 @@ namespace Obfuz
     {
         ObfuscationPassType Type { get; }
 
-        void Start(ObfuscationPassContext ctx);
+        void Start();
 
-        void Stop(ObfuscationPassContext ctx);
+        void Stop();
 
-        void Process(ObfuscationPassContext ctx);
+        void Process();
     }
 }
diff --git a/Editor/ObfusPasses/BasicBlockObfuscationPassBase.cs b/Editor/ObfusPasses/BasicBlockObfuscationPassBase.cs
index b94a721..16e27d0 100644
--- a/Editor/ObfusPasses/BasicBlockObfuscationPassBase.cs
+++ b/Editor/ObfusPasses/BasicBlockObfuscationPassBase.cs
@@ -10,8 +10,9 @@ namespace Obfuz.ObfusPasses
     {
         protected abstract bool NeedObfuscateMethod(MethodDef method);
 
-        public override void Process(ObfuscationPassContext ctx)
+        public override void Process()
         {
+            var ctx = ObfuscationPassContext.Current;
             NotObfuscatedMethodWhiteList whiteList = ctx.whiteList;
             ConfigurablePassPolicy passPolicy = ctx.passPolicy;
             foreach (ModuleDef mod in ctx.toObfuscatedModules)
diff --git a/Editor/ObfusPasses/CallObfus/CallObfusPass.cs b/Editor/ObfusPasses/CallObfus/CallObfusPass.cs
index b51e5a0..a8a9652 100644
--- a/Editor/ObfusPasses/CallObfus/CallObfusPass.cs
+++ b/Editor/ObfusPasses/CallObfus/CallObfusPass.cs
@@ -30,16 +30,17 @@ namespace Obfuz.ObfusPasses.CallObfus
             _obfuscationLevel = settings.callObfuscationLevel;
         }
 
-        public override void Stop(ObfuscationPassContext ctx)
+        public override void Stop()
         {
             _dynamicProxyObfuscator.Done();
         }
 
-        public override void Start(ObfuscationPassContext ctx)
+        public override void Start()
         {
+            var ctx = ObfuscationPassContext.Current;
             _random = ctx.random;
             _encryptor = ctx.encryptor;
-            _dynamicProxyObfuscator = new DefaultCallProxyObfuscator(_random, _encryptor, ctx.constFieldAllocator, _obfuscationLevel);
+            _dynamicProxyObfuscator = new DefaultCallProxyObfuscator(_random, _encryptor, ctx.constFieldAllocator, ctx.moduleEntityManager, _obfuscationLevel);
             _dynamicProxyPolicy = new ConfigurableObfuscationPolicy(ctx.toObfuscatedAssemblyNames, _configFiles);
         }
 
diff --git a/Editor/ObfusPasses/CallObfus/CallProxyAllocator.cs b/Editor/ObfusPasses/CallObfus/CallProxyAllocator.cs
index 0d5a413..f883255 100644
--- a/Editor/ObfusPasses/CallObfus/CallProxyAllocator.cs
+++ b/Editor/ObfusPasses/CallObfus/CallProxyAllocator.cs
@@ -242,18 +242,20 @@ namespace Obfuz.ObfusPasses.CallObfus
     {
         private readonly IRandom _random;
         private readonly IEncryptor _encryptor;
+        private GroupByModuleEntityManager _moduleEntityManager;
         private readonly int _encryptionLevel;
 
-        public CallProxyAllocator(IRandom random, IEncryptor encryptor, int encryptionLevel)
+        public CallProxyAllocator(IRandom random, IEncryptor encryptor, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel)
         {
             _random = random;
             _encryptor = encryptor;
+            _moduleEntityManager = moduleEntityManager;
             _encryptionLevel = encryptionLevel;
         }
 
         private ModuleCallProxyAllocator GetModuleAllocator(ModuleDef mod)
         {
-            return GroupByModuleEntityManager.Ins.GetEntity<ModuleCallProxyAllocator>(mod, () => new ModuleCallProxyAllocator(_random, _encryptor, _encryptionLevel));
+            return _moduleEntityManager.GetEntity<ModuleCallProxyAllocator>(mod, () => new ModuleCallProxyAllocator(_random, _encryptor, _encryptionLevel));
         }
 
         public ProxyCallMethodData Allocate(ModuleDef mod, IMethod method, bool callVir)
@@ -264,7 +266,7 @@ namespace Obfuz.ObfusPasses.CallObfus
 
         public void Done()
         {
-            foreach (var allocator in GroupByModuleEntityManager.Ins.GetEntities<ModuleCallProxyAllocator>())
+            foreach (var allocator in _moduleEntityManager.GetEntities<ModuleCallProxyAllocator>())
             {
                 allocator.Done();
             }
diff --git a/Editor/ObfusPasses/CallObfus/DefaultCallProxyObfuscator.cs b/Editor/ObfusPasses/CallObfus/DefaultCallProxyObfuscator.cs
index 6265556..a549bb8 100644
--- a/Editor/ObfusPasses/CallObfus/DefaultCallProxyObfuscator.cs
+++ b/Editor/ObfusPasses/CallObfus/DefaultCallProxyObfuscator.cs
@@ -13,12 +13,14 @@ namespace Obfuz.ObfusPasses.CallObfus
         private readonly IEncryptor _encryptor;
         private readonly ConstFieldAllocator _constFieldAllocator;
         private readonly CallProxyAllocator _proxyCallAllocator;
+        private readonly GroupByModuleEntityManager _moduleEntityManager;
 
-        public DefaultCallProxyObfuscator(IRandom random, IEncryptor encryptor, ConstFieldAllocator constFieldAllocator, int encryptionLevel)
+        public DefaultCallProxyObfuscator(IRandom random, IEncryptor encryptor, ConstFieldAllocator constFieldAllocator, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel)
         {
             _encryptor = encryptor;
             _constFieldAllocator = constFieldAllocator;
-            _proxyCallAllocator = new CallProxyAllocator(random, _encryptor, encryptionLevel);
+            _moduleEntityManager = moduleEntityManager;
+            _proxyCallAllocator = new CallProxyAllocator(random, _encryptor, moduleEntityManager, encryptionLevel);
         }
 
         public override void Done()
@@ -31,7 +33,7 @@ namespace Obfuz.ObfusPasses.CallObfus
 
             MethodSig sharedMethodSig = MetaUtil.ToSharedMethodSig(calledMethod.Module.CorLibTypes, MetaUtil.GetInflatedMethodSig(calledMethod));
             ProxyCallMethodData proxyCallMethodData = _proxyCallAllocator.Allocate(callerMethod.Module, calledMethod, callVir);
-            DefaultMetadataImporter importer = GroupByModuleEntityManager.Ins.GetDefaultModuleMetadataImporter(callerMethod.Module);
+            DefaultMetadataImporter importer = _moduleEntityManager.GetDefaultModuleMetadataImporter(callerMethod.Module);
 
             if (needCacheCall)
             {
diff --git a/Editor/ObfusPasses/CleanUp/CleanUpInstructionPass.cs b/Editor/ObfusPasses/CleanUp/CleanUpInstructionPass.cs
index ace7d0a..f1578c9 100644
--- a/Editor/ObfusPasses/CleanUp/CleanUpInstructionPass.cs
+++ b/Editor/ObfusPasses/CleanUp/CleanUpInstructionPass.cs
@@ -12,17 +12,18 @@ namespace Obfuz.ObfusPasses.CleanUp
     {
         public override ObfuscationPassType Type => ObfuscationPassType.None;
 
-        public override void Start(ObfuscationPassContext ctx)
+        public override void Start()
         {
         }
 
-        public override void Stop(ObfuscationPassContext ctx)
+        public override void Stop()
         {
 
         }
 
-        public override void Process(ObfuscationPassContext ctx)
+        public override void Process()
         {
+            var ctx = ObfuscationPassContext.Current;
             foreach (ModuleDef mod in ctx.toObfuscatedModules)
             {
                 foreach (TypeDef type in mod.GetTypes())
diff --git a/Editor/ObfusPasses/ConstEncrypt/ConstEncryptPass.cs b/Editor/ObfusPasses/ConstEncrypt/ConstEncryptPass.cs
index 0b62a82..064c90b 100644
--- a/Editor/ObfusPasses/ConstEncrypt/ConstEncryptPass.cs
+++ b/Editor/ObfusPasses/ConstEncrypt/ConstEncryptPass.cs
@@ -27,13 +27,14 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
             _encryptionLevel = settings.encryptionLevel;
         }
 
-        public override void Start(ObfuscationPassContext ctx)
+        public override void Start()
         {
+            var ctx = ObfuscationPassContext.Current;
             _dataObfuscatorPolicy = new ConfigurableEncryptPolicy(ctx.toObfuscatedAssemblyNames, _configFiles);
-            _dataObfuscator = new DefaultConstEncryptor(ctx.random, ctx.encryptor, ctx.rvaDataAllocator, ctx.constFieldAllocator, _encryptionLevel);
+            _dataObfuscator = new DefaultConstEncryptor(ctx.random, ctx.encryptor, ctx.rvaDataAllocator, ctx.constFieldAllocator, ctx.moduleEntityManager, _encryptionLevel);
         }
 
-        public override void Stop(ObfuscationPassContext ctx)
+        public override void Stop()
         {
             _dataObfuscator.Done();
         }
@@ -43,8 +44,6 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
             return _dataObfuscatorPolicy.NeedObfuscateMethod(method);
         }
 
-        private readonly HashSet<FieldDef> _encryptedRvaFields = new HashSet<FieldDef>();
-
         protected override bool TryObfuscateInstruction(MethodDef method, Instruction inst, BasicBlock block, int instructionIndex, IList<Instruction> globalInstructions,
             List<Instruction> outputInstructions, List<Instruction> totalFinalInstructions)
         {
diff --git a/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs b/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs
index c7ab506..b451c54 100644
--- a/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs
+++ b/Editor/ObfusPasses/ConstEncrypt/DefaultConstEncryptor.cs
@@ -16,14 +16,16 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
         private readonly RvaDataAllocator _rvaDataAllocator;
         private readonly ConstFieldAllocator _constFieldAllocator;
         private readonly IEncryptor _encryptor;
+        private readonly GroupByModuleEntityManager _moduleEntityManager;
         private readonly int _encryptionLevel;
 
-        public DefaultConstEncryptor(IRandom random, IEncryptor encryptor, RvaDataAllocator rvaDataAllocator, ConstFieldAllocator constFieldAllocator, int encryptionLevel)
+        public DefaultConstEncryptor(IRandom random, IEncryptor encryptor, RvaDataAllocator rvaDataAllocator, ConstFieldAllocator constFieldAllocator, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel)
         {
             _random = random;
             _encryptor = encryptor;
             _rvaDataAllocator = rvaDataAllocator;
             _constFieldAllocator = constFieldAllocator;
+            _moduleEntityManager = moduleEntityManager;
             _encryptionLevel = encryptionLevel;
         }
 
@@ -39,7 +41,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
 
         private DefaultMetadataImporter GetModuleMetadataImporter(MethodDef method)
         {
-            return GroupByModuleEntityManager.Ins.GetDefaultModuleMetadataImporter(method.Module);
+            return _moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module);
         }
 
         public void ObfuscateInt(MethodDef method, bool needCacheValue, int value, List<Instruction> obfuscatedInstructions)
diff --git a/Editor/ObfusPasses/ExprObfus/ExprObfusPass.cs b/Editor/ObfusPasses/ExprObfus/ExprObfusPass.cs
index f854ecb..468bfce 100644
--- a/Editor/ObfusPasses/ExprObfus/ExprObfusPass.cs
+++ b/Editor/ObfusPasses/ExprObfus/ExprObfusPass.cs
@@ -12,12 +12,12 @@ namespace Obfuz.ObfusPasses.ExprObfus
     {
         public override ObfuscationPassType Type => ObfuscationPassType.ExprObfus;
 
-        public override void Start(ObfuscationPassContext ctx)
+        public override void Start()
         {
 
         }
 
-        public override void Stop(ObfuscationPassContext ctx)
+        public override void Stop()
         {
 
         }
diff --git a/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs b/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs
index 03c5f08..51efea3 100644
--- a/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs
+++ b/Editor/ObfusPasses/FieldEncrypt/DefaultFieldEncryptor.cs
@@ -14,18 +14,20 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
     {
         private readonly IRandom _random;
         private readonly IEncryptor _encryptor;
+        private readonly GroupByModuleEntityManager _moduleEntityManager;
         private readonly int _encryptionLevel;
 
-        public DefaultFieldEncryptor(IRandom random, IEncryptor encryptor, int encryptionLevel)
+        public DefaultFieldEncryptor(IRandom random, IEncryptor encryptor, GroupByModuleEntityManager moduleEntityManager, int encryptionLevel)
         {
             _random = random;
             _encryptor = encryptor;
+            _moduleEntityManager = moduleEntityManager;
             _encryptionLevel = encryptionLevel;
         }
 
         private DefaultMetadataImporter GetMetadataImporter(MethodDef method)
         {
-            return GroupByModuleEntityManager.Ins.GetDefaultModuleMetadataImporter(method.Module);
+            return _moduleEntityManager.GetDefaultModuleMetadataImporter(method.Module);
         }
 
          class FieldEncryptInfo
diff --git a/Editor/ObfusPasses/FieldEncrypt/FieldEncryptPass.cs b/Editor/ObfusPasses/FieldEncrypt/FieldEncryptPass.cs
index f5356bb..84b5b88 100644
--- a/Editor/ObfusPasses/FieldEncrypt/FieldEncryptPass.cs
+++ b/Editor/ObfusPasses/FieldEncrypt/FieldEncryptPass.cs
@@ -27,13 +27,14 @@ namespace Obfuz.ObfusPasses.FieldEncrypt
 
         protected override bool NeedProcessNotObfuscatedAssembly => true;
 
-        public override void Start(ObfuscationPassContext ctx)
+        public override void Start()
         {
-            _memoryEncryptor = new DefaultFieldEncryptor(ctx.random, ctx.encryptor, _encryptionLevel);
+            var ctx = ObfuscationPassContext.Current;
+            _memoryEncryptor = new DefaultFieldEncryptor(ctx.random, ctx.encryptor, ctx.moduleEntityManager, _encryptionLevel);
             _encryptionPolicy = new ConfigurableEncryptPolicy(ctx.toObfuscatedAssemblyNames, _configFiles);
         }
 
-        public override void Stop(ObfuscationPassContext ctx)
+        public override void Stop()
         {
 
         }
diff --git a/Editor/ObfusPasses/InstructionObfuscationPassBase.cs b/Editor/ObfusPasses/InstructionObfuscationPassBase.cs
index 737a448..0fb72ec 100644
--- a/Editor/ObfusPasses/InstructionObfuscationPassBase.cs
+++ b/Editor/ObfusPasses/InstructionObfuscationPassBase.cs
@@ -11,8 +11,9 @@ namespace Obfuz.ObfusPasses
 
         protected abstract bool NeedObfuscateMethod(MethodDef method);
 
-        public override void Process(ObfuscationPassContext ctx)
+        public override void Process()
         {
+            var ctx = ObfuscationPassContext.Current;
             var modules = NeedProcessNotObfuscatedAssembly ? ctx.obfuscatedAndNotObfuscatedModules : ctx.toObfuscatedModules;
             NotObfuscatedMethodWhiteList whiteList = ctx.whiteList;
             ConfigurablePassPolicy passPolicy = ctx.passPolicy;
diff --git a/Editor/ObfusPasses/ObfuscationPassBase.cs b/Editor/ObfusPasses/ObfuscationPassBase.cs
index 5b37576..b3aaf0c 100644
--- a/Editor/ObfusPasses/ObfuscationPassBase.cs
+++ b/Editor/ObfusPasses/ObfuscationPassBase.cs
@@ -11,10 +11,10 @@ namespace Obfuz.ObfusPasses
             return passType.HasFlag(Type);
         }
 
-        public abstract void Start(ObfuscationPassContext ctx);
+        public abstract void Start();
 
-        public abstract void Stop(ObfuscationPassContext ctx);
+        public abstract void Stop();
 
-        public abstract void Process(ObfuscationPassContext ctx);
+        public abstract void Process();
     }
 }
diff --git a/Editor/ObfusPasses/SymbolObfus/SymbolObfusPass.cs b/Editor/ObfusPasses/SymbolObfus/SymbolObfusPass.cs
index 9a73d65..81fae2b 100644
--- a/Editor/ObfusPasses/SymbolObfus/SymbolObfusPass.cs
+++ b/Editor/ObfusPasses/SymbolObfus/SymbolObfusPass.cs
@@ -18,17 +18,17 @@ namespace Obfuz.ObfusPasses.SymbolObfus
             _symbolRename = new SymbolRename(settings);
         }
 
-        public override void Start(ObfuscationPassContext ctx)
+        public override void Start()
         {
-            _symbolRename.Init(ctx);
+            _symbolRename.Init();
         }
 
-        public override void Stop(ObfuscationPassContext ctx)
+        public override void Stop()
         {
             _symbolRename.Save();
         }
 
-        public override void Process(ObfuscationPassContext ctx)
+        public override void Process()
         {
             _symbolRename.Process();
         }
diff --git a/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs b/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
index 735eab7..e58e8e7 100644
--- a/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
+++ b/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
@@ -63,8 +63,9 @@ namespace Obfuz.ObfusPasses.SymbolObfus
             _nameMaker = settings.debug ? NameMakerFactory.CreateDebugNameMaker() :  NameMakerFactory.CreateNameMakerBaseASCIICharSet(settings.obfuscatedNamePrefix);
         }
 
-        public void Init(ObfuscationPassContext ctx)
+        public void Init()
         {
+            var ctx = ObfuscationPassContext.Current;
             _assemblyCache = ctx.assemblyCache;
             _toObfuscatedModules = ctx.toObfuscatedModules;
             _obfuscatedAndNotObfuscatedModules = ctx.obfuscatedAndNotObfuscatedModules;
diff --git a/Editor/ObfuscationPassContext.cs b/Editor/ObfuscationPassContext.cs
index e563aa6..c69d356 100644
--- a/Editor/ObfuscationPassContext.cs
+++ b/Editor/ObfuscationPassContext.cs
@@ -1,5 +1,6 @@
 using dnlib.DotNet;
 using Obfuz.Data;
+using Obfuz.Emit;
 using Obfuz.ObfusPasses;
 using Obfuz.ObfusPasses.SymbolObfus;
 using Obfuz.Utils;
@@ -14,6 +15,11 @@ namespace Obfuz
 
     public class ObfuscationPassContext
     {
+        public static ObfuscationPassContext Current { get; set; }
+
+
+        public GroupByModuleEntityManager moduleEntityManager;
+
         public AssemblyCache assemblyCache;
 
         public List<ModuleDef> toObfuscatedModules;
diff --git a/Editor/Obfuscator.cs b/Editor/Obfuscator.cs
index a55d94c..86568b0 100644
--- a/Editor/Obfuscator.cs
+++ b/Editor/Obfuscator.cs
@@ -158,14 +158,14 @@ namespace Obfuz
             List<ModuleDef> toObfuscatedModules = new List<ModuleDef>();
             List<ModuleDef> obfuscatedAndNotObfuscatedModules = new List<ModuleDef>();
 
-            GroupByModuleEntityManager.Reset();
             LoadAssemblies(assemblyCache, toObfuscatedModules, obfuscatedAndNotObfuscatedModules);
 
 
             var random = new RandomWithKey(_secret, _randomSeed);
             var encryptor = CreateEncryptionVirtualMachine();
-            var rvaDataAllocator = new RvaDataAllocator(random, encryptor);
-            var constFieldAllocator = new ConstFieldAllocator(encryptor, random, rvaDataAllocator);
+            var moduleEntityManager = new GroupByModuleEntityManager();
+            var rvaDataAllocator = new RvaDataAllocator(random, encryptor, moduleEntityManager);
+            var constFieldAllocator = new ConstFieldAllocator(encryptor, random, rvaDataAllocator, moduleEntityManager);
             _ctx = new ObfuscationPassContext
             {
                 assemblyCache = assemblyCache,
@@ -174,6 +174,7 @@ namespace Obfuz
                 toObfuscatedAssemblyNames = _toObfuscatedAssemblyNames,
                 notObfuscatedAssemblyNamesReferencingObfuscated = _notObfuscatedAssemblyNamesReferencingObfuscated,
                 obfuscatedAssemblyOutputDir = _obfuscatedAssemblyOutputDir,
+                moduleEntityManager = moduleEntityManager,
 
                 random = random,
                 encryptor = encryptor,
@@ -182,7 +183,8 @@ namespace Obfuz
                 whiteList = new NotObfuscatedMethodWhiteList(),
                 passPolicy = _passPolicy,
             };
-            pipeline.Start(_ctx);
+            ObfuscationPassContext.Current = _ctx;
+            pipeline.Start();
         }
 
         private void LoadAssemblies(AssemblyCache assemblyCache, List<ModuleDef> toObfuscatedModules, List<ModuleDef> obfuscatedAndNotObfuscatedModules)
@@ -216,13 +218,12 @@ namespace Obfuz
 
         private void DoObfuscation(Pipeline pipeline)
         {
-
-            pipeline.Run(_ctx);
+            pipeline.Run();
         }
 
         private void OnPostObfuscation(Pipeline pipeline)
         {
-            pipeline.Stop(_ctx);
+            pipeline.Stop();
             WriteAssemblies();
         }
     }
diff --git a/Editor/Pipeline.cs b/Editor/Pipeline.cs
index 3b30bbf..9e92d46 100644
--- a/Editor/Pipeline.cs
+++ b/Editor/Pipeline.cs
@@ -15,28 +15,28 @@ namespace Obfuz
             return this;
         }
 
-        public void Start(ObfuscationPassContext ctx)
+        public void Start()
         {
             foreach (var pass in _passes)
             {
-                pass.Start(ctx);
+                pass.Start();
             }
         }
 
-        public void Stop(ObfuscationPassContext ctx)
+        public void Stop()
         {
 
             foreach (var pass in _passes)
             {
-                pass.Stop(ctx);
+                pass.Stop();
             }
         }
 
-        public void Run(ObfuscationPassContext ctx)
+        public void Run()
         {
             foreach (var pass in _passes)
             {
-                pass.Process(ctx);
+                pass.Process();
             }
         }
     }