diff --git a/src/Main.java b/src/Main.java
index 26f705e..19d505d 100644
--- a/src/Main.java
+++ b/src/Main.java
@@ -35,7 +35,7 @@
 //		sandbox3();
 //		sandbox4();
 //		ProofSystem.debug();
-		sandbox5();
+		sandbox6();
 	}
 	
 	static void sandbox1() {
@@ -138,12 +138,48 @@
 		Resource x = new Resource("x", INT, 0);
 		Resource y = new Resource("y", INT, 0);
 		DependencyTerm t1 = new DependencyTerm(a, b, c, d, e);
-		DependencyTerm t2 = new DependencyTerm(x, f, t1);
+		DependencyTerm t2 = new DependencyTerm(t1, f, x);
 		EquationFormula fm = new EquationFormula(t2, y);
+		System.out.println(t1);
+		System.out.println(t2);
+		System.out.println(fm);
 		RewriteInferenceSystem tmp = new RewriteInferenceSystem(List.of(fm), null);
+		tmp.debug();
 		tmp.inference();
 	}
 	
+	static void sandbox6() {
+		Resource uid = new Resource("uid", INT, 1);
+		Resource org = new Resource("org", INT, 1);
+		Resource uadd = new Resource("uadd", INT, 1);
+		Resource cid = new Resource("cid", INT, 1);
+		Resource add = new Resource("add", INT, 1);
+		Resource addP = new Resource("add'", INT, 1);
+		Resource cidP = new Resource("cid'", INT, 1);
+		Resource orgP = new Resource("org'", INT, 1);
+		Resource uidP = new Resource("uid'", INT, 1);
+		Resource uaddP = new Resource("uadd'", INT, 1);
+		Resource x = new Resource("x", INT, 0);
+		Resource y = new Resource("y", INT, 0);
+		Resource z = new Resource("z", INT, 0);
+		
+		DependencyTerm t1 = new DependencyTerm(add, cid, org);
+		DependencyTerm t2 = new DependencyTerm(addP, cidP, orgP);
+		DependencyTerm t3 = new DependencyTerm(orgP, uidP, x);
+		DependencyTerm t4 = new DependencyTerm(add, cid, y);
+		DependencyTerm t5 = new DependencyTerm(uaddP, uidP, x);
+		
+		EquationFormula f1 = new EquationFormula(uadd, t1);
+		EquationFormula f2 = new EquationFormula(uaddP, t2);
+		EquationFormula f3 = new EquationFormula(t3, y);
+		EquationFormula f4 = new EquationFormula(t4, t5);
+		
+		RewriteInferenceSystem tmp = new RewriteInferenceSystem(List.of(f1, f2, f3), f4);
+		tmp.debug();
+		tmp.inference();
+		
+	}
+	
 	
 	@SneakyThrows
 	static Expression parse(String expr) {
diff --git a/src/inference/rewrite/RewriteInferenceSystem.java b/src/inference/rewrite/RewriteInferenceSystem.java
index 8ce7ec7..303ea2e 100644
--- a/src/inference/rewrite/RewriteInferenceSystem.java
+++ b/src/inference/rewrite/RewriteInferenceSystem.java
@@ -44,9 +44,18 @@
 		
 	}
 	
+	public void debug() {
+		System.out.println("constraintFormulas: " + constraintFormulas.toString());
+		System.out.println("invariantFormulas: " + invariantFormulas.toString());
+		System.out.println("inputFormula: " + inputFormula.toString());
+		System.out.println("conditionalFormulas: " + conditionalFormulas.toString());
+		System.out.println("conclusion: " + conclusion.toString());
+	}
+	
 	public boolean inference() {
 		Map<Resource, List<Resource>> resourceTree = new HashMap<>();
 		Resource root = parseDependencyTerm(inputFormula.getLeftSideHand(), resourceTree, new ArrayList<>());
+		System.out.println(resourceTree);
 		return false;
 	}
 	
@@ -68,7 +77,7 @@
 		Resource root;
 		DependencyTerm depTerm = (DependencyTerm) term;
 		EvaluatableTerm dependingTerm = depTerm.getDependingTerm();
-		List<EvaluatableTerm> dependedTerms = depTerm.getDependedTerms();
+		List<Resource> dependedTerms = depTerm.getDependedResources();
 		List<EvaluatableTerm> argumentTerms = depTerm.getArgumentTerms();
 		root = parseDependencyTerm(dependingTerm, resourceTree, tops);
 		List<Resource> nextTops = new ArrayList<>();
diff --git a/src/models/terms/DependencyTerm.java b/src/models/terms/DependencyTerm.java
index d24b955..a84c945 100644
--- a/src/models/terms/DependencyTerm.java
+++ b/src/models/terms/DependencyTerm.java
@@ -11,7 +11,7 @@
 public class DependencyTerm extends EvaluatableTerm{
 
 	private EvaluatableTerm dependingTerm;
-	private List<EvaluatableTerm> dependedTerms = new ArrayList<>();
+	private List<Resource> dependedResources = new ArrayList<>();
 	private List<EvaluatableTerm> argumentTerms = new ArrayList<>();
 	
 	
@@ -29,22 +29,22 @@
 //		addChild(argumentTerm);
 //	}
 	
-	public DependencyTerm(EvaluatableTerm dependingTerm, List<EvaluatableTerm> dependedTerms, List<EvaluatableTerm> argumentTerms) {
+	public DependencyTerm(EvaluatableTerm dependingTerm, List<Resource> dependedTerms, List<EvaluatableTerm> argumentTerms) {
 		super(
 				new Symbol(":", 1 + dependedTerms.size() + argumentTerms.size()), 
 				dependedTerms.get(0).getOrder() == argumentTerms.get(0).getOrder() ? dependedTerms.get(0).getOrder() : argumentTerms.get(0).getOrder() - 1,
 				dependingTerm.getSize() + argumentTerms.get(0).getSize() + dependedTerms.get(0).getSize()
 		);
 		boolean dependedTermsOrderCheck = dependedTerms.stream().allMatch(e -> e.getOrder() == dependedTerms.get(0).getOrder());
-		boolean argumentTermsOrderCheck = argumentTerms.stream().allMatch(e -> e.getOrder() == argumentTerms.get(0).getOrder());
-		if (! (dependedTermsOrderCheck && argumentTermsOrderCheck)) {
+//		boolean argumentTermsOrderCheck = argumentTerms.stream().allMatch(e -> e.getOrder() == argumentTerms.get(0).getOrder());
+		if (! (dependedTermsOrderCheck)) {
 			throw new RuntimeException("Orders are not all equals");
 		}
 		if (dependedTerms.size() != argumentTerms.size()) {
 			throw new RuntimeException("Size not equals");
 		}
 		this.dependingTerm = dependingTerm;
-		this.dependedTerms = new ArrayList<>(dependedTerms);
+		this.dependedResources = new ArrayList<>(dependedTerms);
 		this.argumentTerms = new ArrayList<>(argumentTerms);
 		addChild(dependingTerm);
 		for (int i = 0; i < dependedTerms.size(); i++) {
@@ -56,7 +56,7 @@
 	public DependencyTerm(EvaluatableTerm dependingTerm, EvaluatableTerm ...terms) {
 		this(
 				dependingTerm, 
-				IntStream.range(0, terms.length).filter(i -> i % 2 == 0).mapToObj(i -> terms[i]).toList(), 
+				IntStream.range(0, terms.length).filter(i -> i % 2 == 0).mapToObj(i -> (Resource) terms[i]).toList(), 
 				IntStream.range(0, terms.length).filter(i -> i % 2 == 1).mapToObj(i -> terms[i]).toList()
 			);
 	}
@@ -130,8 +130,8 @@
 		sb.append('[');
 		sb.append(getDependingTerm().toString());
 		sb.append(" : ");
-		for (int i = 0; i < dependedTerms.size(); i++) {
-			sb.append(dependedTerms.get(i).toString());
+		for (int i = 0; i < dependedResources.size(); i++) {
+			sb.append(dependedResources.get(i).toString());
 			sb.append(" -> ");
 			sb.append(argumentTerms.get(i).toString());
 			sb.append(", ");
@@ -148,8 +148,8 @@
 		sb.append('[');
 		sb.append(getDependingTerm().toStringWithOrder());
 		sb.append(" : ");
-		for (int i = 0; i < dependedTerms.size(); i++) {
-			sb.append(dependedTerms.get(i).toStringWithOrder());
+		for (int i = 0; i < dependedResources.size(); i++) {
+			sb.append(dependedResources.get(i).toStringWithOrder());
 			sb.append(" -> ");
 			sb.append(argumentTerms.get(i).toStringWithOrder());
 			sb.append(", ");
@@ -170,7 +170,7 @@
 		DependencyTerm term = (DependencyTerm) another;
 		
 		return dependingTerm.equals(term.getDependingTerm()) && 
-				dependedTerms.stream().sorted().toList().equals(term.getDependedTerms().stream().sorted().toList()) &&
+				dependedResources.stream().sorted().toList().equals(term.getDependedResources().stream().sorted().toList()) &&
 				argumentTerms.stream().sorted().toList().equals(term.getArgumentTerms().stream().sorted().toList());
 	}
 
@@ -183,7 +183,7 @@
 	public Object clone() {
 		return new DependencyTerm(
 				(EvaluatableTerm) dependingTerm.clone(),
-				new ArrayList<>(dependedTerms),
+				new ArrayList<>(dependedResources),
 				new ArrayList<>(argumentTerms)
 		);
 	}