diff --git a/src/main/java/models/terms/meta/MetaDependencyGenerator.java b/src/main/java/models/terms/meta/MetaDependencyGenerator.java
new file mode 100644
index 0000000..ed0c6e7
--- /dev/null
+++ b/src/main/java/models/terms/meta/MetaDependencyGenerator.java
@@ -0,0 +1,8 @@
+package models.terms.meta;
+
+@FunctionalInterface
+public interface MetaDependencyGenerator {
+
+	MetaRDLTerm generate(int i);
+	
+}
diff --git a/src/main/java/models/terms/meta/MetaDependencyTermGenerator.java b/src/main/java/models/terms/meta/MetaDependencyTermGenerator.java
new file mode 100644
index 0000000..197ccd1
--- /dev/null
+++ b/src/main/java/models/terms/meta/MetaDependencyTermGenerator.java
@@ -0,0 +1,10 @@
+package models.terms.meta;
+
+@FunctionalInterface
+public interface MetaDependencyTermGenerator {
+	
+	record TermPair(MetaRDLTerm dependedTerm, MetaRDLTerm argTerm) {};
+	
+	TermPair generate(int i);
+	
+}
diff --git a/src/main/java/models/terms/meta/MetaRDLTerm.java b/src/main/java/models/terms/meta/MetaRDLTerm.java
index 39e8b1e..b6de276 100644
--- a/src/main/java/models/terms/meta/MetaRDLTerm.java
+++ b/src/main/java/models/terms/meta/MetaRDLTerm.java
@@ -27,12 +27,17 @@
 import models.terms.Resource;
 import utils.Permutation;
 
-@Getter
 public class MetaRDLTerm extends RDLTerm {
 
+	@Getter
 	protected TermType termType;
+	@Getter
 	protected LinearRightNormalizedType linearRightNormalizedType = LinearRightNormalizedType.UNDEFINED;
 	
+	private boolean isDynamic = false;
+	private MetaDependencyTermGenerator metaDependencyTermGenerator;
+	private MetaDependencyGenerator metaDependencyGenerator;
+	
 	protected MetaRDLTerm(Symbol symbol, TermType termType, int size) {
 		super(symbol, -1, size);
 		this.termType = termType;
@@ -58,6 +63,14 @@
 		this(dependingTerm, new TreeSet<>(Set.of(dependedTerm)));
 	}
 	
+	public MetaRDLTerm(MetaRDLTerm dependingTerm, MetaDependencyGenerator generator) {
+		super(new Symbol(":", 1), -1, -1);
+		addChild(dependingTerm);
+		this.metaDependencyGenerator = generator;
+		this.termType = TermType.META_DEPENDENCY;
+		this.isDynamic = true;
+	}
+	
 	//dependency term
 	public MetaRDLTerm(MetaRDLTerm dependingTerm, List<MetaRDLTerm> terms) {
 		super(new Symbol(":", terms.size() + 1), -1, -1);
@@ -95,6 +108,14 @@
 	public MetaRDLTerm(MetaRDLTerm dependingTerm, MetaRDLTerm ...terms) {
 		this(dependingTerm, Arrays.asList(terms));
 	}
+	
+	public MetaRDLTerm(MetaRDLTerm dependingTerm, MetaDependencyTermGenerator generator) {
+		super(new Symbol(":", 1), -1, -1);
+		addChild(dependingTerm);
+		this.metaDependencyTermGenerator = generator;
+		this.termType = TermType.META_DEPENDENCY_TERM;
+		this.isDynamic = true;
+	}
 
 	public RDLTerm substitute(Map<Variable, RDLTerm> binding) {
 		if (isDependency()) {
@@ -269,6 +290,13 @@
 		}
 	}
 	
+	private boolean dynamicMatchCheck(RDLTerm another, Map<Variable, RDLTerm> binding, Map<Variable, OrderVariableConstraint> orderConstraint) {
+		if (isDependency()) {
+			
+		}
+		return false;
+	}
+	
 	public boolean checkTermType(Class<? extends RDLTerm> clazz) {
 		return clazz.isAssignableFrom(termType.getBaseTermClass());
 	}
diff --git a/src/test/java/terms/DependencyTermTest.java b/src/test/java/terms/DependencyTermTest.java
index bd673a0..78d9c50 100644
--- a/src/test/java/terms/DependencyTermTest.java
+++ b/src/test/java/terms/DependencyTermTest.java
@@ -81,6 +81,40 @@
 		assertTrue(mt4.isMatchedBy(t2, binding, orderConstraint));
 		RDLTerm t = mt1.substitute(binding);
 		assertEquals(t, t1);
-		System.out.println(binding);
 	}
+	
+	@Test
+	void MatchTest2() {
+		MetaResource x = new MetaResource(new Variable("x"));
+		MetaResource y = new MetaResource(new Variable("y"));
+		MetaResource z = new MetaResource(new Variable("z"));
+		MetaResource v = new MetaResource(new Variable("v"));
+		MetaResource w = new MetaResource(new Variable("w"));
+		MetaResource p = new MetaResource(new Variable("p"));
+		MetaResource q = new MetaResource(new Variable("q"));
+		
+		DependencyTerm t1 = new DependencyTerm(a, b, c, d, e);
+		DependencyTerm t2 = new DependencyTerm(a, d, e, f, g);
+		MetaRDLTerm mt1 = new MetaRDLTerm(x, p, q, v, w);
+		MetaRDLTerm mt2 = new MetaRDLTerm(x, v, w, y, z);
+		Map<Variable, RDLTerm> binding = new HashMap<>();
+		Map<Variable, OrderVariableConstraint> orderConstraint = new HashMap<>();
+		assertTrue(mt1.isMatchedBy(t1, binding, orderConstraint));
+		assertTrue(mt2.isMatchedBy(mt2, binding, orderConstraint));
+	}
+	
+	@Test
+	void OrderTest() {
+		Resource text = new Resource("text", Utils.INT, 2);
+		Resource wNo = new Resource("wNo", Utils.INT, 2);
+		Resource v = new Resource("v", Utils.INT, 1);
+		Resource scId = new Resource("scId", Utils.INT, 1);
+		Resource curScId = new Resource("curScId", Utils.INT, 0);
+		Resource curWNo = new Resource("curWNo", Utils.INT, 1);
+		
+		DependencyTerm t1 = new DependencyTerm(text, wNo, v);
+		DependencyTerm t2 = new DependencyTerm(t1, scId, curScId, v, curWNo);
+		assertEquals(t2.getOrder(), 1);
+	}
+	
 }