diff --git a/src/main/java/models/terms/meta/MetaRDLTerm.java b/src/main/java/models/terms/meta/MetaRDLTerm.java
index 4f72e6a..e86b1e5 100644
--- a/src/main/java/models/terms/meta/MetaRDLTerm.java
+++ b/src/main/java/models/terms/meta/MetaRDLTerm.java
@@ -25,20 +25,13 @@
 import models.terms.LinearRightNormalizedType;
 import models.terms.RDLTerm;
 import models.terms.Resource;
-import models.terms.meta.MetaTermPairGenerator.TermPair;
 import utils.Permutation;
-
+@Getter
 public class MetaRDLTerm extends RDLTerm {
 
-	@Getter
 	protected TermType termType;
-	@Getter
 	protected LinearRightNormalizedType linearRightNormalizedType = LinearRightNormalizedType.UNDEFINED;
 	
-	private boolean isDynamic = false;
-	private MetaTermPairGenerator metaDependencyTermGenerator;
-	private MetaTermGenerator metaDependencyGenerator;
-	
 	protected MetaRDLTerm(Symbol symbol, TermType termType, int size) {
 		super(symbol, -1, size);
 		this.termType = termType;
@@ -58,21 +51,12 @@
 		}
 		this.size = size;
 		this.termType = TermType.META_DEPENDENCY;
-		this.metaDependencyGenerator = (index, depth, isLast) -> (MetaRDLTerm) this.getChild(index + 1);
 	}
 	
 	public MetaRDLTerm(MetaRDLTerm dependingTerm, MetaRDLTerm dependedTerm) {
 		this(dependingTerm, new TreeSet<>(Set.of(dependedTerm)));
 	}
 	
-	public MetaRDLTerm(MetaRDLTerm dependingTerm, MetaTermGenerator 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);
@@ -105,44 +89,32 @@
 			addChild(argTerm);
  		}
 		this.termType = TermType.META_DEPENDENCY_TERM;
-		this.metaDependencyTermGenerator = (index, depth, isLast) -> new TermPair((MetaRDLTerm) this.getChild(index * 2 + 1), (MetaRDLTerm) this.getChild(index * 2 + 2));
 	}
 	
 	public MetaRDLTerm(MetaRDLTerm dependingTerm, MetaRDLTerm ...terms) {
 		this(dependingTerm, Arrays.asList(terms));
 	}
 	
-	public MetaRDLTerm(MetaRDLTerm dependingTerm, MetaTermPairGenerator 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) {
 		return substitute(binding, 0);
 	}
 	
 	protected RDLTerm substitute(Map<Variable, RDLTerm> binding, int depth) {
 		RDLTerm dependingTerm = (RDLTerm) getChild(0);
-		List<EvaluatableTerm> dependedTerms = new ArrayList<>();
 		if (dependingTerm instanceof MetaRDLTerm) {
 			dependingTerm = ((MetaRDLTerm) dependingTerm).substitute(binding, depth + 1);
 		}
 		if (isDependency()) {
-			for (int i = 0; i < binding.size(); i++) {
-				if ((! isDynamic) && (i >= getChildren().size() - 1)) break;
-				RDLTerm term = metaDependencyGenerator.generate(i, depth, i == getChildren().size() - 2);
-				try {
-					if (term instanceof MetaRDLTerm metaTerm) {
-						term = metaTerm.substitute(binding, depth + 1);
-					}
-				} catch(SubstituteFailedException e) {
-					continue;
+			List<EvaluatableTerm> dependedTerms = new ArrayList<>();
+			for (int i = 0; i < getChildren().size() - 1; i++) {
+				RDLTerm dependedTerm = (RDLTerm) getChild(i);
+				if (dependedTerm instanceof MetaRDLTerm metaTerm) {
+					dependedTerm = metaTerm.substitute(binding, depth + 1);
 				}
-				if (term instanceof EvaluatableTerm te) {
+				if (dependedTerm instanceof EvaluatableTerm te) {
 					dependedTerms.add(te);
+				} else {
+					throw new SubstituteFailedException("Syntax error");
 				}
 			}
 			try {
@@ -152,27 +124,21 @@
 			}
 		}
 		else if (isDependencyTerm()) {
-			List<EvaluatableTerm> terms = new ArrayList<>();
-			for (int i = 0; i < binding.size(); i++) {
-				if ((! isDynamic) && (i >= (getChildren().size() - 1) / 2)) break;
-				TermPair termPair = metaDependencyTermGenerator.generate(i, depth, i == (getChildren().size() - 1) / 2 - 1);
-				RDLTerm dependedTerm = termPair.dependedTerm();
-				RDLTerm argTerm = termPair.argTerm();
-				try {
-					if (dependedTerm instanceof MetaRDLTerm metaTerm) {
-						dependedTerm = metaTerm.substitute(binding, depth + 1);
-					}
-					if (argTerm instanceof MetaRDLTerm metaTerm) {
-						argTerm = metaTerm.substitute(binding, depth + 1);
-					}
-					terms.add((EvaluatableTerm) dependedTerm);
-					terms.add((EvaluatableTerm) argTerm);
-				} catch (SubstituteFailedException e) {
-					continue;
+			List<EvaluatableTerm> termPairs = new ArrayList<>();
+			for (int i = 0; i < (getChildren().size() - 1) / 2; i++) {
+				RDLTerm dependedTerm = (RDLTerm) getChild(i * 2);
+				RDLTerm argTerm = (RDLTerm) getChild(i * 2 + 1);
+				if (dependedTerm instanceof MetaRDLTerm metaTerm) {
+					dependedTerm = metaTerm.substitute(binding, depth + 1);
 				}
+				if (argTerm instanceof MetaRDLTerm metaTerm) {
+					argTerm = metaTerm.substitute(binding, depth + 1);
+				}
+				termPairs.add((EvaluatableTerm) dependedTerm);
+				termPairs.add((EvaluatableTerm) argTerm);
 			}
 			try {
-				return new DependencyTerm((EvaluatableTerm) dependingTerm, terms);
+				return new DependencyTerm((EvaluatableTerm) dependingTerm, termPairs);
 			} catch (SyntaxException e) {
 				throw new SubstituteFailedException(e.getMessage());
 			}
@@ -185,11 +151,11 @@
 	}
 	
 	public Set<MatchConstraint> isMatchedBy(RDLTerm another) {
-		return isMatchedBy(another, 0);
+		return isMatchedBy(another, MatchConstraint.createDefault(), 0);
 	}
 	
-	protected Set<MatchConstraint> isMatchedBy(RDLTerm another, int depth) {
-		return isMatchedBy(another, MatchConstraint.createDefault(), depth);
+	public Set<MatchConstraint> isMatchedBy(RDLTerm another, MatchConstraint constraint) {
+		return isMatchedBy(another, constraint, 0);
 	}
 	
 	public Set<MatchConstraint> isMatchedBy(RDLTerm another, Set<MatchConstraint> constraints) {
@@ -204,18 +170,11 @@
 		return result;
 	}
 	
-	public Set<MatchConstraint> isMatchedBy(RDLTerm another, MatchConstraint constraint) {
-		return isMatchedBy(another, constraint, 0);
-	}
-	
 	protected Set<MatchConstraint> isMatchedBy(RDLTerm another, MatchConstraint constraint, int depth) {
 		Set<MatchConstraint> result = new HashSet<>();
 		if (! another.getClass().isAssignableFrom(this.termType.getBaseTermClass())) {
 			return result;
 		}
-		if (!isDynamic && this.getChildren().size() != another.getChildren().size()) {
-			return result;
-		}
 		if (isDependencyTerm() && (! islinearRightNormalizedMatchedBy(another))) {
 			return result;
 		}
@@ -230,78 +189,122 @@
 				return result;
 			}
 		}
-		if (isDependencyTerm() && !isVariable()) {
-			for (List<Integer> perm : Permutation.permutation((another.getChildren().size() - 1) / 2)) {
-				Set<MatchConstraint> res2 = new HashSet<>(res);
-				boolean flg = true;
-				for (int i = 0; i < perm.size(); i++) {
-					int j = perm.get(i);
-					TermPair termPair = this.metaDependencyTermGenerator.generate(j, depth, false);
-					RDLTerm dependedChild = termPair.dependedTerm();
-					RDLTerm argChild = termPair.argTerm();
-					RDLTerm anotherDependedChild = (RDLTerm) another.getChild(i * 2 + 1);
-					RDLTerm anotherArgChild = (RDLTerm) another.getChild(i * 2 + 2);
-					if (dependedChild instanceof MetaRDLTerm) {
-						MetaRDLTerm metaChild = (MetaRDLTerm) dependedChild;
-						res2 = metaChild.isMatchedBy(anotherDependedChild, res2, depth + 1);
-						if (res2.isEmpty()) {
-							flg = false;
-							break;
-						}
-					} else {
-						if (!(dependedChild.equals(anotherDependedChild))) {
-							flg = false;
-							break;
-						}
+		if (isDependencyTerm()) {
+//			for (List<Integer> perm : Permutation.permutation((another.getChildren().size() - 1) / 2)) {
+//				Set<MatchConstraint> res2 = new HashSet<>(res);
+//				boolean flg = true;
+//				for (int metaTermIndex = 0; metaTermIndex < perm.size(); metaTermIndex++) {
+//					int anotherTermIndex = perm.get(metaTermIndex);
+//					RDLTerm metaDependedTerm = (RDLTerm) getChild(metaTermIndex * 2 + 1);
+//					RDLTerm metaArgTerm = (RDLTerm) getChild(metaTermIndex * 2 + 2);
+//					RDLTerm anotherDependedChild = (RDLTerm) another.getChild(anotherTermIndex * 2 + 1);
+//					RDLTerm anotherArgChild = (RDLTerm) another.getChild(anotherTermIndex * 2 + 2);
+//					if (metaDependedTerm instanceof MetaRDLTerm metaTerm) {
+//						res2 = metaTerm.isMatchedBy(anotherDependedChild, res2, depth + 1);
+//						if (res2.isEmpty()) {
+//							flg = false;
+//							break;
+//						}
+//					} else {
+//						if (!(metaDependedTerm.equals(anotherDependedChild))) {
+//							flg = false;
+//							break;
+//						}
+//					}
+//					if (metaArgTerm instanceof MetaRDLTerm metaTerm) {
+//						res2 = metaTerm.isMatchedBy(anotherArgChild, res2, depth + 1);
+//						if (res2.isEmpty()) {
+//							flg = false;
+//							break;
+//						}
+//					} else {
+//						if (!(metaArgTerm.equals(anotherArgChild))) {
+//							flg = false;
+//							break;
+//						}
+//					}
+//				}
+//				if (flg) {
+//					result.addAll(res2);
+//					break;
+//				}
+//			}
+//			return result;
+			result.addAll(dependencyTermMatch(another, result, depth));
+		} else if (isDependency()) {
+//			for (List<Integer> perm : Permutation.permutation(another.getChildren().size() - 1)) {
+//				Set<MatchConstraint> res2 = new HashSet<>(res);
+//				boolean flg = true;
+//				for (int metaTermIndex = 0; metaTermIndex < perm.size(); metaTermIndex++) {
+//					int anotherTermIndex = perm.get(metaTermIndex);
+//					RDLTerm metaDependedTerm = (RDLTerm) getChild(metaTermIndex + 1);
+//					RDLTerm anotherDependedTerm = (RDLTerm) another.getChild(anotherTermIndex + 1);
+//					if (metaDependedTerm instanceof MetaRDLTerm metaTerm) {
+//						res2 = metaTerm.isMatchedBy(anotherDependedTerm, res2, depth + 1);
+//						if (res2.isEmpty()) {
+//							flg = false;
+//							break;
+//						}
+//					} else {
+//						if (!(metaDependedTerm.equals(anotherDependedTerm))) {
+//							flg = false;
+//							break;
+//						}
+//					}
+//				}
+//				if (flg) {
+//					result.addAll(res2);
+//					break;
+//				}
+			result.addAll(dependencyMatch(another, result, depth));
+		}
+		return result;
+	}
+	
+	private Set<MatchConstraint> dependencyMatch(RDLTerm another, Set<MatchConstraint> constraint, int depth) {
+		for (List<Integer> perm : Permutation.permutation(another.getChildren().size() - 1)) {
+			Set<MatchConstraint> result = new HashSet<>(constraint);
+			for (int metaTermIndex = 0; metaTermIndex < perm.size(); metaTermIndex++) {
+				int anotherTermIndex = perm.get(metaTermIndex);
+				RDLTerm metaDependedTerm = (RDLTerm) getChild(metaTermIndex + 1);
+				RDLTerm anotherDependedTerm = (RDLTerm) another.getChild(anotherTermIndex + 1);
+				if (metaDependedTerm instanceof MetaRDLTerm metaTerm) {
+					result = metaTerm.isMatchedBy(anotherDependedTerm, result, depth + 1);
+					if (result.isEmpty()) {
+						break;
 					}
-					if (argChild instanceof MetaRDLTerm) {
-						MetaRDLTerm metaChild = (MetaRDLTerm) argChild;
-						res2 = metaChild.isMatchedBy(anotherArgChild, res2, depth + 1);
-						if (res2.isEmpty()) {
-							flg = false;
-							break;
-						}
-					} else {
-						if (!(argChild.equals(anotherArgChild))) {
-							flg = false;
-							break;
-						}
+				} else {
+					if (!(metaDependedTerm.equals(anotherDependedTerm))) {
+						break;
 					}
 				}
-				if (flg) {
-					result.addAll(res2);
-				}
-			}
-			return result;
-		} else if (isDependency() && !isVariable()) {
-			for (List<Integer> perm : Permutation.permutation(another.getChildren().size() - 1)) {
-				Set<MatchConstraint> res2 = new HashSet<>(res);
-				boolean flg = true;
-				for (int i = 0; i < perm.size(); i++) {
-					int j = perm.get(i);
-					RDLTerm dependedChild = this.metaDependencyGenerator.generate(j, depth, false);
-					RDLTerm anotherDependedChild = (RDLTerm) another.getChild(i + 1);
-					if (dependedChild instanceof MetaRDLTerm) {
-						MetaRDLTerm metaChild = (MetaRDLTerm) dependedChild;
-						res2 = metaChild.isMatchedBy(anotherDependedChild, res2, depth + 1);
-						if (res2.isEmpty()) {
-							flg = false;
-							break;
-						}
-					} else {
-						if (!(dependedChild.equals(anotherDependedChild))) {
-							flg = false;
-							break;
-						}
-					}
-				}
-				if (flg) {
-					result.addAll(res2);
-				}
 			}
 			return result;
 		}
-		return result;
+		return new HashSet<>();
+	}
+	
+	private Set<MatchConstraint> dependencyTermMatch(RDLTerm another, Set<MatchConstraint> constraint, int depth) {
+		for (List<Integer> perm : Permutation.permutation(another.getChildren().size() - 1)) {
+			Set<MatchConstraint> result = new HashSet<>(constraint);
+			for (int metaTermIndex = 0; metaTermIndex < perm.size(); metaTermIndex++) {
+				int anotherTermIndex = perm.get(metaTermIndex);
+				RDLTerm metaDependedTerm = (RDLTerm) getChild(metaTermIndex + 1);
+				RDLTerm anotherDependedTerm = (RDLTerm) another.getChild(anotherTermIndex + 1);
+				if (metaDependedTerm instanceof MetaRDLTerm metaTerm) {
+					result = metaTerm.isMatchedBy(anotherDependedTerm, result, depth + 1);
+					if (result.isEmpty()) {
+						break;
+					}
+				} else {
+					if (!(metaDependedTerm.equals(anotherDependedTerm))) {
+						break;
+					}
+				}
+			}
+			return result;
+		}
+		return new HashSet<>();
 	}
 	
 	public boolean checkTermType(Class<? extends RDLTerm> clazz) {