diff --git a/include/obf/pass.hpp b/include/obf/pass.hpp
index 24fdd41..0c9088f 100644
--- a/include/obf/pass.hpp
+++ b/include/obf/pass.hpp
@@ -63,11 +63,53 @@ class pass_t {
   explicit pass_t(decomp::sym_type_t sym_type) : m_sym_type(sym_type){};
 
   /// <summary>
-  /// virtual method which must be implimented by the pass that inherits this
-  /// class.
+  /// This virtual method is invoked before the recomp stage of Theodosius. This
+  /// allows you to manipulate symbols in a generic manner.
   /// </summary>
   /// <param name="sym">a symbol of the same type of m_sym_type.</param>
-  virtual void run(decomp::symbol_t* sym) = 0;
+  virtual void pre_recomp_pass(decomp::symbol_t* sym) = 0;
+
+  /// <summary>
+  /// This virtual method is invoked prior to calling the "allocator". This
+  /// allows you to manipulate the symbol prior to memory being allocated for
+  /// it.
+  /// </summary>
+  /// <param name="sym">The symbol that memory is being allocated for.</param>
+  /// <param name="size">The size of the symbol that memory is being allocated
+  /// for.</param>
+  /// <returns>returns the size of the symbol.</returns>
+  virtual std::uint32_t pre_allocation_pass(decomp::symbol_t* sym,
+                                            std::uint32_t size) = 0;
+
+  /// <summary>
+  /// This virtual method is invoked after the call to the "allocator". This
+  /// allows you to manipulate the symbol after memory has been allocated for
+  /// it.
+  /// </summary>
+  /// <param name="dest">Allocation address (can be linear virtual address or
+  /// file offset address)</param>
+  /// <param name="sym">The symbol for which allocation was made for.</param>
+  /// <param name="size">Size of the allocation.</param>
+  virtual void post_allocation_pass(decomp::symbol_t* sym,
+                                    std::uintptr_t dest,
+                                    std::uint32_t size) = 0;
+
+  /// <summary>
+  /// This virtual method is invoked prior to calling the "copier". This allows
+  /// you to manipulate the symbol prior to it being copied into memory.
+  /// </summary>
+  /// <param name="sym">Symbol being copied into memory...</param>
+  /// <param name="dest">Memory destination of the copy...</param>
+  /// <param name="size"></param>
+  /// <returns></returns>
+  virtual std::uintptr_t pre_copier_pass(decomp::symbol_t* sym,
+                                         std::uintptr_t dest,
+                                         std::uint32_t size) = 0;
+
+  virtual void post_copier_pass() = 0;
+
+  virtual void pre_resolver_pass() = 0;
+  virtual void post_resolver_pass() = 0;
 
   /// <summary>
   /// gets the passes symbol type.