diff --git a/src/.DS_Store b/src/.DS_Store
new file mode 100644
index 00000000..028ba8f2
Binary files /dev/null and b/src/.DS_Store differ
diff --git a/src/sneps/.DS_Store b/src/sneps/.DS_Store
new file mode 100644
index 00000000..bfa7bf5f
Binary files /dev/null and b/src/sneps/.DS_Store differ
diff --git a/src/sneps/network/.DS_Store b/src/sneps/network/.DS_Store
new file mode 100644
index 00000000..8e0c95df
Binary files /dev/null and b/src/sneps/network/.DS_Store differ
diff --git a/src/sneps/network/BoundedlyConcatenableGraph.java b/src/sneps/network/BoundedlyConcatenableGraph.java
new file mode 100644
index 00000000..6262634c
--- /dev/null
+++ b/src/sneps/network/BoundedlyConcatenableGraph.java
@@ -0,0 +1,309 @@
+package sneps.network;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+public class BoundedlyConcatenableGraph {
+	
+	public static Hashtable<Integer, Hashtable<Integer,Integer>> printhashtableConcatenableLow (int [] data , int lowerlimit){
+		
+
+		if(lowerlimit <= data.length ) {
+			
+
+		Hashtable<Integer, String> StartNodes = new Hashtable<Integer, String>();
+		Hashtable<Integer, String> EndNodes = new Hashtable<Integer, String>();
+		
+		String start = "Start";
+		String end = "End";
+		
+		StartNodes.put(data[0], start);
+		EndNodes.put(data[data.length-1], end);
+	
+		Hashtable<Integer, Hashtable<Integer,Integer>>  hashtable = new Hashtable<Integer, Hashtable<Integer,Integer>>();
+		Hashtable<Integer,Integer> temp = new Hashtable<Integer,Integer>();
+		int counter = 0;
+		
+		for(int i = 0; i<data.length-1;i++) {
+			
+			Hashtable<Integer,Integer> ht = new Hashtable<Integer,Integer>();
+			ht.put(data[i+1],data[i+1]);
+			hashtable.put(data[i], ht);
+			counter++;
+			
+		}
+		
+		temp.put(0,0);
+		hashtable.put(data[counter], temp);
+		
+		System.out.println();
+		System.out.println(StartNodes);
+		System.out.println(EndNodes);
+		System.out.println();
+	
+	return hashtable;
+		}
+		else return null;
+	
+}
+public static Hashtable<Integer, Hashtable<Integer,Integer>> printhashtableConcatenableHigh (int [] data , int higherlimit){
+		
+
+		if(higherlimit >= data.length ) {
+			
+
+		Hashtable<Integer, String> StartNodes = new Hashtable<Integer, String>();
+		Hashtable<Integer, String> EndNodes = new Hashtable<Integer, String>();
+		
+		String start = "Start";
+		String end = "End";
+		
+		StartNodes.put(data[0], start);
+		EndNodes.put(data[data.length-1], end);
+	
+		Hashtable<Integer, Hashtable<Integer,Integer>>  hashtable = new Hashtable<Integer, Hashtable<Integer,Integer>>();
+		Hashtable<Integer,Integer> temp = new Hashtable<Integer,Integer>();
+		int counter = 0;
+		
+		for(int i = 0; i<data.length-1;i++) {
+			
+			Hashtable<Integer,Integer> ht = new Hashtable<Integer,Integer>();
+			ht.put(data[i+1],data[i+1]);
+			hashtable.put(data[i], ht);
+			counter++;
+			
+		}
+		
+		temp.put(0,0);
+		hashtable.put(data[counter], temp);
+		
+		System.out.println();
+		System.out.println(StartNodes);
+		System.out.println(EndNodes);
+		System.out.println();
+	
+	return hashtable;
+		}
+		else return null;
+	
+}
+
+public static Hashtable<Integer, Hashtable<Integer, Integer>> printhashtableReversibleLow (int [] data , int lowerlimit){ 
+	
+	if(lowerlimit <= data.length ) {
+
+	Hashtable<Integer, String> StartNodes = new Hashtable<Integer, String>();
+	Hashtable<Integer, String> EndNodes = new Hashtable<Integer, String>();
+	
+	String start = "Start";
+	String end = "End";
+	
+	StartNodes.put(data[0], start);
+	EndNodes.put(data[data.length-1], end);
+	
+	Hashtable<Integer, Hashtable<Integer, Integer>>  hashtable = new Hashtable<Integer, Hashtable<Integer, Integer>>();
+	
+	Hashtable<Integer, Integer> aaa = new Hashtable<Integer, Integer>();
+	aaa.put(data[1], data[1]);
+	hashtable.put(data[0], aaa);
+	
+	for(int i = 1; i<data.length-1;i++) {
+	
+		Hashtable<Integer, Integer> aa = new Hashtable<Integer, Integer>();
+		aa.put(data[i+1], data[i+1]);
+		aa.put(data[i-1], data[i-1]);
+		hashtable.put(data[i], aa);
+		
+}	
+	Hashtable<Integer, Integer> aaaa = new Hashtable<Integer, Integer>();
+	aaaa.put(data[data.length-2], data[data.length-2]);
+	hashtable.put(data[data.length-1], aaaa);
+	
+	System.out.println();
+	System.out.println(StartNodes);
+	System.out.println(EndNodes);
+	System.out.println();
+	
+return hashtable;
+	}
+	else return null;
+
+}
+
+public static Hashtable<Integer, Hashtable<Integer, Integer>> printhashtableReversibleHigh (int [] data , int higherlimit){ 
+	
+	if(higherlimit >= data.length ) {
+
+	Hashtable<Integer, String> StartNodes = new Hashtable<Integer, String>();
+	Hashtable<Integer, String> EndNodes = new Hashtable<Integer, String>();
+	
+	String start = "Start";
+	String end = "End";
+	
+	StartNodes.put(data[0], start);
+	EndNodes.put(data[data.length-1], end);
+	
+	Hashtable<Integer, Hashtable<Integer, Integer>>  hashtable = new Hashtable<Integer, Hashtable<Integer, Integer>>();
+	
+	Hashtable<Integer, Integer> aaa = new Hashtable<Integer, Integer>();
+	aaa.put(data[1], data[1]);
+	hashtable.put(data[0], aaa);
+	
+	for(int i = 1; i<data.length-1;i++) {
+	
+		Hashtable<Integer, Integer> aa = new Hashtable<Integer, Integer>();
+		aa.put(data[i+1], data[i+1]);
+		aa.put(data[i-1], data[i-1]);
+		hashtable.put(data[i], aa);
+		
+}	
+	Hashtable<Integer, Integer> aaaa = new Hashtable<Integer, Integer>();
+	aaaa.put(data[data.length-2], data[data.length-2]);
+	hashtable.put(data[data.length-1], aaaa);
+	
+	System.out.println();
+	System.out.println(StartNodes);
+	System.out.println(EndNodes);
+	System.out.println();
+	
+return hashtable;
+	}
+	else return null;
+
+}
+public static Hashtable<Integer, Hashtable<Integer, Integer>> printhashtableSeparableLow (int [] data , int lowerlimit){ 
+	
+	if(lowerlimit <= data.length ) {
+
+	Hashtable<Integer, String> StartNodes = new Hashtable<Integer, String>();
+	Hashtable<Integer, String> EndNodes = new Hashtable<Integer, String>();
+	
+	String start = "Start";
+	String end = "End";
+	for(int i = 0; i< data.length; i++) {
+		
+		StartNodes.put(data[i], start);
+		EndNodes.put(data[i], end);
+	}
+	
+	
+	Hashtable<Integer, Hashtable<Integer, Integer>>  hashtable = new Hashtable<Integer, Hashtable<Integer, Integer>>();
+	
+	Hashtable<Integer, Integer> aaa = new Hashtable<Integer, Integer>();
+	aaa.put(data[1], data[1]);
+	hashtable.put(data[0], aaa);
+	
+	for(int i = 1; i<data.length-1;i++) {
+	
+		Hashtable<Integer, Integer> aa = new Hashtable<Integer, Integer>();
+		aa.put(data[i+1], data[i+1]);
+		aa.put(data[i-1], data[i-1]);
+		hashtable.put(data[i], aa);
+		
+}	
+	Hashtable<Integer, Integer> aaaa = new Hashtable<Integer, Integer>();
+	aaaa.put(data[data.length-2], data[data.length-2]);
+	hashtable.put(data[data.length-1], aaaa);
+	
+	System.out.println();
+	System.out.println(StartNodes);
+	System.out.println(EndNodes);
+	System.out.println();
+	
+return hashtable;
+	}
+	else return null;
+
+}
+
+public static Hashtable<Integer, Hashtable<Integer, Integer>> printhashtableSeparableHigh (int [] data , int higherlimit){ 
+	
+	if(higherlimit >= data.length ) {
+
+	Hashtable<Integer, String> StartNodes = new Hashtable<Integer, String>();
+	Hashtable<Integer, String> EndNodes = new Hashtable<Integer, String>();
+	
+	String start = "Start";
+	String end = "End";
+	for(int i = 0; i< data.length; i++) {
+		
+		StartNodes.put(data[i], start);
+		EndNodes.put(data[i], end);
+	}
+	
+	
+	Hashtable<Integer, Hashtable<Integer, Integer>>  hashtable = new Hashtable<Integer, Hashtable<Integer, Integer>>();
+	
+	Hashtable<Integer, Integer> aaa = new Hashtable<Integer, Integer>();
+	aaa.put(data[1], data[1]);
+	hashtable.put(data[0], aaa);
+	
+	for(int i = 1; i<data.length-1;i++) {
+	
+		Hashtable<Integer, Integer> aa = new Hashtable<Integer, Integer>();
+		aa.put(data[i+1], data[i+1]);
+		aa.put(data[i-1], data[i-1]);
+		hashtable.put(data[i], aa);
+		
+}	
+	Hashtable<Integer, Integer> aaaa = new Hashtable<Integer, Integer>();
+	aaaa.put(data[data.length-2], data[data.length-2]);
+	hashtable.put(data[data.length-1], aaaa);
+	
+	System.out.println();
+	System.out.println(StartNodes);
+	System.out.println(EndNodes);
+	System.out.println();
+	
+return hashtable;
+	}
+	else return null;
+
+}
+public static void removehashtable (Hashtable<Integer, Hashtable<Integer,Integer>> hashtable , int key) {
+	
+	Enumeration<Hashtable<Integer, Integer>> enumration = hashtable.elements();
+	while(enumration.hasMoreElements()){
+        Hashtable<Integer, Integer> elmnt = enumration.nextElement();
+        if(elmnt.containsKey(key)){
+        	elmnt.remove(key);
+        }
+    }
+	hashtable.remove(key); 
+	System.out.println();
+}
+
+public static boolean searchpath (Hashtable<Integer, Hashtable<Integer,Integer>> hashtable , int [] arr) {
+	
+	for(int i=0; i<arr.length-1;i++) {
+		
+			int element = arr[i];
+			int nextelement = arr[i+1];
+			
+			try {
+				if(hashtable.get(element).get(nextelement) == nextelement) {
+					
+				}
+				else 
+					return false;
+			} 
+			catch (NullPointerException e){
+				
+				return false;
+			}
+			
+		
+	}
+	return true;
+	
+}
+
+	public static void main(String[] args) {
+		
+		int[] a = new int[]{ 1,2,3 };
+		System.out.print(printhashtableConcatenableLow(a, 4));
+		
+
+	}
+
+}
diff --git a/src/sneps/network/ConcatenableOnlyGraph.java b/src/sneps/network/ConcatenableOnlyGraph.java
new file mode 100644
index 00000000..b06c1655
--- /dev/null
+++ b/src/sneps/network/ConcatenableOnlyGraph.java
@@ -0,0 +1,136 @@
+package sneps.network;
+
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Set;
+
+public class ConcatenableOnlyGraph {
+	
+	private Hashtable<Integer, String> StartNodes;
+	private Hashtable<Integer, String> EndNodes;
+	private String start;
+	private String end;
+	private Hashtable<Integer, Hashtable<Integer,Integer>>  hashtable;
+	private Hashtable<Integer,Integer> temp;
+	
+	
+	public ConcatenableOnlyGraph() {
+		 StartNodes = new Hashtable<Integer, String>();
+		 EndNodes = new Hashtable<Integer, String>();
+		 start = "Start";
+		 end = "End";
+		 hashtable = new Hashtable<Integer, Hashtable<Integer,Integer>>();
+		 temp = new Hashtable<Integer,Integer>();
+		 
+	}
+	
+	public Hashtable<Integer, Hashtable<Integer,Integer>> printhashtableConcatenable (int [] data){
+
+
+		this.StartNodes.put(data[0], start);
+		this.EndNodes.put(data[data.length-1], end);
+		
+		if(this.hashtable.isEmpty()) {
+		
+		int counter = 0;
+
+		for(int i = 0; i<data.length-1;i++) {
+			
+			Hashtable<Integer,Integer> ht = new Hashtable<Integer,Integer>();
+		
+			
+			ht.put(data[i+1],data[i+1]);
+			hashtable.put(data[i], ht);
+			counter++;
+		
+	}
+		temp.put(0,0);
+		hashtable.put(data[counter], temp);
+		
+		System.out.println();
+		System.out.println(StartNodes);
+		System.out.println(EndNodes);
+		System.out.println();
+	
+		}
+		
+		else
+			
+		{	int counter = 0;
+			Hashtable<Integer, Hashtable<Integer,Integer>> temporary = new Hashtable<Integer, Hashtable<Integer,Integer>>();
+			for(int i = 0; i<data.length-1;i++) {
+				
+				Hashtable<Integer,Integer> ht = new Hashtable<Integer,Integer>();
+			
+				
+				ht.put(data[i+1],data[i+1]);
+				temporary.put(data[i], ht);
+				counter++;
+			
+		}
+			temp.put(0,0);
+			temporary.put(data[counter], temp);
+			this.hashtable.putAll(temporary);
+//			this.hashtable.forEach(
+//				    (key, value) -> temporary.merge( key, value, (v1, v2) -> v1 == v2 ? v1 : v2 ));
+		
+			}
+		return hashtable; 
+}
+	
+	public static void removehashtable (Hashtable<Integer, Hashtable<Integer,Integer>> hashtable , int key) {
+			
+			Enumeration<Hashtable<Integer, Integer>> enumration = hashtable.elements();
+			while(enumration.hasMoreElements()){
+	            Hashtable<Integer, Integer> elmnt = enumration.nextElement();
+	            if(elmnt.containsKey(key)){
+	            	elmnt.remove(key);
+	            }
+	        }
+			hashtable.remove(key); 
+			System.out.println();
+		}
+	
+	public boolean searchpath (Hashtable<Integer, Hashtable<Integer,Integer>> hashtable , int [] arr) {
+		
+		if(this.StartNodes.containsKey(arr[0]) && this.EndNodes.containsKey(arr[arr.length-1])) {
+			
+			for(int i=0; i<arr.length-1;i++) {
+				
+					int element = arr[i];
+					int nextelement = arr[i+1];
+					
+					try {
+						if(hashtable.get(element).get(nextelement) == nextelement) {
+							
+						}
+						else 
+							return false;
+					} 
+					catch (NullPointerException e){
+						
+						return false;
+					}
+					
+				
+			}
+			return true;
+		}
+		else return false;
+			
+		}
+
+
+	public static void main(String[] args) {
+		
+		ConcatenableOnlyGraph a = new ConcatenableOnlyGraph();
+		int[] x = new int[]{ 1,2,3,4 };
+		int[] y = new int[]{ 1,2 };
+		int [] z = new int[] {1,2,3,4};
+		System.out.println(a.searchpath(a.printhashtableConcatenable(x), y));
+		System.out.println(a.searchpath(a.printhashtableConcatenable(x), z));
+
+	}
+
+}
diff --git a/src/sneps/network/ConcatenableReversibleGraph.java b/src/sneps/network/ConcatenableReversibleGraph.java
new file mode 100644
index 00000000..d4e61f50
--- /dev/null
+++ b/src/sneps/network/ConcatenableReversibleGraph.java
@@ -0,0 +1,134 @@
+package sneps.network;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+public class ConcatenableReversibleGraph {
+	
+	private Hashtable<Integer, String> StartNodes;
+	private Hashtable<Integer, String> EndNodes;
+	private String start;
+	private String end;
+	private Hashtable<Integer, Hashtable<Integer,Integer>>  hashtable;
+	private Hashtable<Integer, Integer> aaa;
+	private Hashtable<Integer, Integer> aaaa;
+	
+	public ConcatenableReversibleGraph(){
+		 StartNodes = new Hashtable<Integer, String>();
+		 EndNodes = new Hashtable<Integer, String>();
+		 start = "Start";
+		 end = "End";
+		 hashtable = new Hashtable<Integer, Hashtable<Integer,Integer>>();
+		 aaa = new Hashtable<Integer, Integer>();
+		 aaaa = new Hashtable<Integer, Integer>();
+	}
+
+	
+	public Hashtable<Integer, Hashtable<Integer, Integer>> printhashtableReversible (int [] data){ 
+
+		this.StartNodes.put(data[0], start);
+		this.EndNodes.put(data[data.length-1], end);
+		this.EndNodes.put(data[0], end);
+		this.StartNodes.put(data[data.length-1], start);
+		
+		if(this.hashtable.isEmpty()) {
+	
+		aaa.put(data[1], data[1]);
+		hashtable.put(data[0], aaa);
+		
+		for(int i = 1; i<data.length-1;i++) {
+		
+			Hashtable<Integer, Integer> aa = new Hashtable<Integer, Integer>();
+			aa.put(data[i+1], data[i+1]);
+			aa.put(data[i-1], data[i-1]);
+			hashtable.put(data[i], aa);
+			
+	}	
+		aaaa.put(data[data.length-2], data[data.length-2]);
+		hashtable.put(data[data.length-1], aaaa);
+		
+		System.out.println();
+		System.out.println(StartNodes);
+		System.out.println(EndNodes);
+		System.out.println();
+		}
+		else 
+		{
+			Hashtable<Integer,Integer> temp = new Hashtable<Integer,Integer>();
+			Hashtable<Integer,Integer> tempo = new Hashtable<Integer,Integer>();
+			Hashtable<Integer, Hashtable<Integer,Integer>> tempor = new Hashtable<Integer, Hashtable<Integer,Integer>>();
+			
+			temp.put(data[1], data[1]);
+			tempor.put(data[0], temp);
+			
+			for(int i = 1; i<data.length-1;i++) {
+			
+				Hashtable<Integer, Integer> aa = new Hashtable<Integer, Integer>();
+				aa.put(data[i+1], data[i+1]);
+				aa.put(data[i-1], data[i-1]);
+				tempor.put(data[i], aa);	
+		}		
+			tempo.put(data[data.length-2], data[data.length-2]);
+			tempor.put(data[data.length-1], tempo);
+			this.hashtable.putAll(tempor);
+			
+		}
+	return hashtable;
+	
+}
+	
+	public static void removehashtable (Hashtable<Integer, Hashtable<Integer,Integer>> hashtable , int key) {
+		
+		Enumeration<Hashtable<Integer, Integer>> enumration = hashtable.elements();
+		while(enumration.hasMoreElements()){
+            Hashtable<Integer, Integer> elmnt = enumration.nextElement();
+            if(elmnt.containsKey(key)){
+            	elmnt.remove(key);
+            }
+        }
+		hashtable.remove(key); 
+		System.out.println();
+	}
+
+	public boolean searchpath (Hashtable<Integer, Hashtable<Integer,Integer>> hashtable , int [] arr) {
+			
+		if(this.StartNodes.containsKey(arr[0]) && this.EndNodes.containsKey(arr[0]) && this.StartNodes.containsKey(arr[arr.length-1]) && this.EndNodes.containsKey(arr[arr.length-1])) {
+			for(int i=0; i<arr.length-1;i++) {
+				
+					int element = arr[i];
+					int nextelement = arr[i+1];
+					
+					try {
+						if(hashtable.get(element).get(nextelement) == nextelement) {
+							
+						}
+						else 
+							return false;
+					} 
+					catch (NullPointerException e){
+						
+						return false;
+					}
+					
+				
+			}
+			return true;}
+		else return false;
+			
+		}
+	
+public static void main(String[] args) {
+		
+		ConcatenableReversibleGraph a = new ConcatenableReversibleGraph();
+		int[] x = new int[]{ 1,2,3 };	
+		int[] y = new int[]{ 3,2,1 };
+		int[] z = new int[]{ 2,1,3 };
+		int[] zz = new int[]{ 2,1,3 };
+		System.out.println(a.printhashtableReversible(x));
+		System.out.println(a.searchpath(a.printhashtableReversible(x), y));
+		System.out.println(a.searchpath(a.printhashtableReversible(x), z));
+		System.out.println(a.searchpath(a.printhashtableReversible(x), zz));
+		
+	}
+
+}
diff --git a/src/sneps/network/ConcatenableSeparableGraph.java b/src/sneps/network/ConcatenableSeparableGraph.java
new file mode 100644
index 00000000..92e92e8a
--- /dev/null
+++ b/src/sneps/network/ConcatenableSeparableGraph.java
@@ -0,0 +1,132 @@
+package sneps.network;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+public class ConcatenableSeparableGraph {
+	
+	private Hashtable<Integer, String> StartNodes;
+	private Hashtable<Integer, String> EndNodes;
+	private String start;
+	private String end;
+	private Hashtable<Integer, Hashtable<Integer,Integer>>  hashtable;
+	private Hashtable<Integer, Integer> aaa;
+	private Hashtable<Integer, Integer> aaaa;
+	
+	public ConcatenableSeparableGraph(){
+		 StartNodes = new Hashtable<Integer, String>();
+		 EndNodes = new Hashtable<Integer, String>();
+		 start = "Start";
+		 end = "End";
+		 hashtable = new Hashtable<Integer, Hashtable<Integer,Integer>>();
+		 aaa = new Hashtable<Integer, Integer>();
+		 aaaa = new Hashtable<Integer, Integer>();
+	}
+
+	
+	public Hashtable<Integer, Hashtable<Integer, Integer>> printhashtableSeparable (int [] data){ 
+
+		for(int ii =0; ii<data.length;ii++) {
+			this.StartNodes.put(data[ii], start);
+			this.EndNodes.put(data[ii], end);
+		}
+		
+		if(this.hashtable.isEmpty()) {
+	
+		aaa.put(data[1], data[1]);
+		hashtable.put(data[0], aaa);
+		
+		for(int i = 1; i<data.length-1;i++) {
+		
+			Hashtable<Integer, Integer> aa = new Hashtable<Integer, Integer>();
+			aa.put(data[i+1], data[i+1]);
+			aa.put(data[i-1], data[i-1]);
+			hashtable.put(data[i], aa);
+			
+	}	
+		aaaa.put(data[data.length-2], data[data.length-2]);
+		hashtable.put(data[data.length-1], aaaa);
+		
+		System.out.println();
+		System.out.println(StartNodes);
+		System.out.println(EndNodes);
+		System.out.println();
+		}
+		else 
+		{
+			Hashtable<Integer,Integer> temp = new Hashtable<Integer,Integer>();
+			Hashtable<Integer,Integer> tempo = new Hashtable<Integer,Integer>();
+			Hashtable<Integer, Hashtable<Integer,Integer>> tempor = new Hashtable<Integer, Hashtable<Integer,Integer>>();
+			
+			temp.put(data[1], data[1]);
+			tempor.put(data[0], temp);
+			
+			for(int i = 1; i<data.length-1;i++) {
+			
+				Hashtable<Integer, Integer> aa = new Hashtable<Integer, Integer>();
+				aa.put(data[i+1], data[i+1]);
+				aa.put(data[i-1], data[i-1]);
+				tempor.put(data[i], aa);	
+		}		
+			tempo.put(data[data.length-2], data[data.length-2]);
+			tempor.put(data[data.length-1], tempo);
+			this.hashtable.putAll(tempor);
+			
+		}
+	return hashtable;
+	
+}
+	
+	public static void removehashtable (Hashtable<Integer, Hashtable<Integer,Integer>> hashtable , int key) {
+		
+		Enumeration<Hashtable<Integer, Integer>> enumration = hashtable.elements();
+		while(enumration.hasMoreElements()){
+            Hashtable<Integer, Integer> elmnt = enumration.nextElement();
+            if(elmnt.containsKey(key)){
+            	elmnt.remove(key);
+            }
+        }
+		hashtable.remove(key); 
+		System.out.println();
+	}
+
+	public boolean searchpath (Hashtable<Integer, Hashtable<Integer,Integer>> hashtable , int [] arr) {
+			
+			for(int i=0; i<arr.length-1;i++) {
+				
+					int element = arr[i];
+					int nextelement = arr[i+1];
+					
+					try {
+						if(hashtable.get(element).get(nextelement) == nextelement) {
+							
+						}
+						else 
+							return false;
+					} 
+					catch (NullPointerException e){
+						
+						return false;
+					}
+					
+				
+			}
+			return true;
+			
+		}
+	
+public static void main(String[] args) {
+		
+	    ConcatenableSeparableGraph a = new ConcatenableSeparableGraph();
+		int[] x = new int[]{ 1,2,3 };	
+		int[] y = new int[]{ 3,2,1 };
+		int[] z = new int[]{ 2,3 };
+		int[] zz = new int[]{ 2,1,3 };
+		System.out.println(a.printhashtableSeparable(x));
+		System.out.println(a.searchpath(a.printhashtableSeparable(x), y));
+		System.out.println(a.searchpath(a.printhashtableSeparable(x), z));
+		System.out.println(a.searchpath(a.printhashtableSeparable(x), zz));
+		
+	}
+
+}
diff --git a/src/sneps/network/cables/.DS_Store b/src/sneps/network/cables/.DS_Store
new file mode 100644
index 00000000..cc676d47
Binary files /dev/null and b/src/sneps/network/cables/.DS_Store differ
diff --git a/src/sneps/network/cables/Cable.java b/src/sneps/network/cables/Cable.java
index c24ff956..3c8c63ff 100644
--- a/src/sneps/network/cables/Cable.java
+++ b/src/sneps/network/cables/Cable.java
@@ -13,7 +13,7 @@
 import java.io.Serializable;
 
 import sneps.network.classes.Relation;
-import sneps.network.classes.setClasses.NodeSet;
+import sneps.network.classes.setClasses.NodeCollection;
 
 public abstract class Cable implements Serializable{
 	
@@ -23,10 +23,10 @@ public abstract class Cable implements Serializable{
 	private Relation relation;
 	
 	/**
-	 * The node set containing the nodes that are pointed to by
+	 * The node collection containing the nodes that are pointed to by
 	 * 	the arcs of this cable.
 	 */
-	private NodeSet nodeSet;
+	private NodeCollection nodeCollection;
 	
 	/**
 	 * The constructor of this class
@@ -36,9 +36,9 @@ public abstract class Cable implements Serializable{
 	 * @param ns
 	 * 			the nodes included in this cable.
 	 */
-	public Cable(Relation relation, NodeSet ns){
+	public Cable(Relation relation, NodeCollection nc){
 		this.relation = relation;
-		this.nodeSet = ns;
+		this.nodeCollection = nc;
 	}
 	
 	/**
@@ -51,11 +51,11 @@ public Relation getRelation(){
 
 	/**
 	 * 
-	 * @return the node set that contains the nodes included in this
+	 * @return the node collection that contains the nodes included in this
 	 * 	cable.
 	 */
-	public NodeSet getNodeSet(){
-		return this.nodeSet;
+	public NodeCollection getNodeCollection(){
+		return this.nodeCollection;
 	}
 	
 	/**
@@ -63,7 +63,7 @@ public NodeSet getNodeSet(){
 	 */
 	@Override
 	public String toString(){
-		return this.relation.toString()+" "+this.nodeSet.toString();
+		return this.relation.toString()+" "+this.nodeCollection.toString();
 	}
 
 }
diff --git a/src/sneps/network/cables/DownCable.java b/src/sneps/network/cables/DownCable.java
index ebe97464..30577106 100644
--- a/src/sneps/network/cables/DownCable.java
+++ b/src/sneps/network/cables/DownCable.java
@@ -13,6 +13,7 @@
 import java.io.Serializable;
 
 import sneps.network.classes.Relation;
+import sneps.network.classes.setClasses.NodeCollection;
 import sneps.network.classes.setClasses.NodeSet;
 
 public class DownCable extends Cable implements Serializable{
@@ -24,8 +25,8 @@ public class DownCable extends Cable implements Serializable{
 	 * @param nodeSet
 	 * 			the nodes included in this down cable.
 	 */
-	public DownCable(Relation relation, NodeSet nodeSet) {
-		super(relation, nodeSet);
+	public DownCable(Relation relation, NodeCollection nodeCollection) {
+		super(relation, nodeCollection);
 		// TODO does this resembles what we agreed to do with semantic classes??
 		//this.updateSemanticClass();
 	}
diff --git a/src/sneps/network/cables/UpCable.java b/src/sneps/network/cables/UpCable.java
index c32ea048..2f5fbf16 100644
--- a/src/sneps/network/cables/UpCable.java
+++ b/src/sneps/network/cables/UpCable.java
@@ -15,6 +15,7 @@
 import java.io.Serializable;
 
 import sneps.network.Node;
+import sneps.network.classes.setClasses.NodeCollection;
 import sneps.network.classes.setClasses.NodeSet;
 
 public class UpCable extends Cable implements Serializable{
@@ -26,7 +27,7 @@ public class UpCable extends Cable implements Serializable{
 	 * 			the relation that labels the arcs of this up cable.
 	 */
 	public UpCable(Relation relation) {
-		super(relation, new NodeSet());	
+		super(relation, new NodeCollection());	
 	}
 	
 	/**
@@ -36,8 +37,14 @@ public UpCable(Relation relation) {
 	 * 			be added or removed from the up cable after its creation.
 	 */
 	public void addNode(Node node){
-		this.getNodeSet().addNode(node);
+		
+		this.getNodeCollection().VectoraddNode(node);
 	}
+	
+	public void addNodee(Node node){
+			
+			this.getNodeCollection().LinkedListaddNode(node);
+		}
 
 	/**
 	 * 
@@ -46,6 +53,10 @@ public void addNode(Node node){
 	 * 			be added or removed from the up cable after its creation.
 	 */
 	public void removeNode(Node node){
-		this.getNodeSet().removeNode(node);
+		this.getNodeCollection().VectorremoveNode(node);
+	}
+	
+	public void removeNodee(Node node){
+		this.getNodeCollection().LinkedListremoveNode(node);
 	}
 }
diff --git a/src/sneps/network/classes/.DS_Store b/src/sneps/network/classes/.DS_Store
new file mode 100644
index 00000000..80721aec
Binary files /dev/null and b/src/sneps/network/classes/.DS_Store differ
diff --git a/src/sneps/network/classes/Relation.java b/src/sneps/network/classes/Relation.java
index 32b677e0..3e3d09a8 100644
--- a/src/sneps/network/classes/Relation.java
+++ b/src/sneps/network/classes/Relation.java
@@ -1,233 +1,279 @@
-/**
- * @className Relation.java
- * 
- * @ClassDescription This is the class that represents the labeled, directed arcs 
- * 	that are used to connect the nodes in SNePS network. The class is implemented
- * 	as a 6-tuple (name, type, adjust, limit, path and quantifier).
- * 
- * @author Nourhan Zakaria
- * @version 2.00 18/6/2014
- */
-package sneps.network.classes;
-
-import java.io.Serializable;
-
-import sneps.exceptions.CustomException;
-import sneps.network.Network;
-import sneps.network.paths.Path;
-
-public class Relation implements Serializable {
-
-	public static Relation andAnt, ant, cq, arg, min, max, i, threshMax, thresh, action, obj, precondition, act, when,
-			whenever, doo, iff, effect, plan, goal, vars, suchthat, elsee, obj1, obj2, obj3, obj4, obj5, obj6, obj7,
-			obj8, obj9, obj10;
-
-	/**
-	 * the name (string) that should label any arc representing this relation. Any
-	 * relation in SNePS is uniquely identified by its name.
-	 */
-	private String name;
-
-	/**
-	 * the name of the semantic class that represents the semantic type of the nodes
-	 * that this relation can point to.
-	 */
-	private String type;
-
-	/**
-	 * the string that represents the adjustability of the relation. It can be one
-	 * of three options: 'reduce', 'expand' or 'none'.
-	 */
-	private String adjust;
-
-	/**
-	 * the number that represents the minimum number of nodes that this relation can
-	 * point to within a down-cable.
-	 */
-	private int limit;
-
-	/**
-	 * the path defined for this relation to be used in path-based inference.
-	 */
-	private Path path;
-
-	/**
-	 * a boolean that tells whether this relation is a quantifier relation (true if
-	 * the relation is a quantifier, and false otherwise).
-	 */
-	private boolean quantifier;
-
-	/**
-	 * The constructor of this class.
-	 * 
-	 * @param n
-	 *            a string representing the name of the relation
-	 * @param t
-	 *            a string representing the name of the semantic type of the nodes
-	 *            that this relation can point to.
-	 * @param a
-	 *            a string representing the adjustability of the relations. 'reduce'
-	 *            if the relation is reducible. 'expand' if the relation is
-	 *            expandable. 'none' if the relation is neither reducible nor
-	 *            expandable.
-	 * @param l
-	 *            an int representing the limit of the relation.
-	 */
-	public Relation(String n, String t, String a, int l) {
-		this.name = n;
-		this.type = t;
-		this.adjust = a;
-		this.limit = l;
-		this.path = null;
-		setQuantifier();
-	}
-
-	public Relation(String name, String type) {
-		this.name = name;
-		this.type = type;
-		this.limit = 1;
-		this.adjust = "none";
-		this.path = null;
-		setQuantifier();
-
-	}
-
-	/**
-	 * @return the name of the current relation.
-	 */
-	public String getName() {
-		return this.name;
-	}
-
-	/**
-	 * @return the name of the semantic type of the nodes that can be pointed to by
-	 *         the current relation.
-	 */
-	public String getType() {
-		return this.type;
-	}
-
-	/**
-	 * @return the adjustability of the current relation. ('reduce', 'expand' or
-	 *         'none')
-	 */
-	public String getAdjust() {
-		return this.adjust;
-	}
-
-	/**
-	 * @return the limit of the current relation.
-	 */
-	public int getLimit() {
-		return this.limit;
-	}
-
-	/**
-	 * @return the path defined for the current relation. (can return null if there
-	 *         is no defined path for the current relation).
-	 */
-	public Path getPath() {
-		return this.path;
-	}
-
-	/**
-	 * @param path
-	 *            a Path that will be defined for the current relation to be used in
-	 *            path-based inference.
-	 */
-	public void setPath(Path path) {
-		this.path = path;
-	}
-
-	/**
-	 * @return true if the current relation is a quantifier relation, and false
-	 *         otherwise.
-	 */
-	public boolean isQuantifier() {
-		return this.quantifier;
-	}
-
-	/**
-	 * This method sets the boolean quantifier to true if the name of the current
-	 * relation represents a quantifier relation.
-	 */
-	public void setQuantifier() {
-		if (name.equals("forall") || name.equals("min") || name.equals("max") || name.equals("thresh")
-				|| name.equals("threshmax") || name.equals("emin") || name.equals("emax") || name.equals("etot")
-				|| name.equals("pevb") || name.equals("vars")) {
-			this.quantifier = true;
-		}
-	}
-
-	/**
-	 * This method overrides the default equals method inherited from the Object
-	 * class.
-	 * 
-	 * @param obj
-	 *            an Object that is to be compared to the current relation to check
-	 *            whether they are equal.
-	 * 
-	 * @return true if the given object is an instance of the Relation class and has
-	 *         the same name as the current relation, and false otherwise.
-	 */
-	@Override
-	public boolean equals(Object obj) {
-		if (!obj.getClass().getSimpleName().equals("Relation"))
-			return false;
-		if (!this.name.equals(((Relation) obj).getName()))
-			return false;
-		return true;
-	}
-
-	/**
-	 * This method overrides the default toString method inherited from the Object
-	 * class.
-	 * 
-	 * @return a string representing the name of the current relation.
-	 */
-	@Override
-	public String toString() {
-		return this.name;
-	}
-
-	public static void createDefaultRelations() {
-		andAnt = Network.defineRelation("&ant", "Proposition", "none", 1);
-		ant = Network.defineRelation("ant", "Proposition", "none", 1);
-		cq = Network.defineRelation("cq", "Proposition", "none", 1);
-		arg = Network.defineRelation("arg", "Proposition", "none", 1);
-		min = Network.defineRelation("min", "Infimum", "none", 1);
-		max = Network.defineRelation("max", "Infimum", "none", 1);
-		i = Network.defineRelation("i", "Infimum", "none", 1);
-		thresh = Network.defineRelation("thresh", "Infimum", "none", 1);
-		threshMax = Network.defineRelation("threshmax", "Infimum", "none", 1);
-
-		action = Network.defineRelation("action", "Action", "none", 1);
-
-		obj = Network.defineRelation("obj", "Entity", "none", 1);
-
-		obj1 = Network.defineRelation("obj1", "Entity", "none", 1);
-		obj2 = Network.defineRelation("obj2", "Entity", "none", 1);
-		obj3 = Network.defineRelation("obj3", "Entity", "none", 1);
-		obj4 = Network.defineRelation("obj4", "Entity", "none", 1);
-		obj5 = Network.defineRelation("obj5", "Entity", "none", 1);
-		obj6 = Network.defineRelation("obj6", "Entity", "none", 1);
-		obj7 = Network.defineRelation("obj7", "Entity", "none", 1);
-		obj8 = Network.defineRelation("obj8", "Entity", "none", 1);
-		obj9 = Network.defineRelation("obj9", "Entity", "none", 1);
-		obj10 = Network.defineRelation("obj10", "Entity", "none", 1);
-
-		precondition = Network.defineRelation("precondition", "Proposition", "none", 1);
-		act = Network.defineRelation("act", "Act", "none", 1);
-		doo = Network.defineRelation("do", "Act", "none", 1);
-		iff = Network.defineRelation("if", "Proposition", "none", 1);
-		when = Network.defineRelation("when", "Proposition", "none", 1);
-		whenever = Network.defineRelation("whenever", "Proposition", "none", 1);
-		plan = Network.defineRelation("plan", "Act", "none", 1);
-		goal = Network.defineRelation("goal", "Proposition", "none", 1);
-		effect = Network.defineRelation("effect", "Proposition", "none", 1);
-		suchthat = Network.defineRelation("suchthat", "Proposition", "none", 1);
-		vars = Network.defineRelation("vars", "Infimum", "none", 1);
-		elsee = Network.defineRelation("else", "Act", "none", 1);
-	}
-
+/**
+ * @className Relation.java
+ * 
+ * @ClassDescription This is the class that represents the labeled, directed arcs 
+ * 	that are used to connect the nodes in SNePS network. The class is implemented
+ * 	as a 6-tuple (name, type, decoration, limit, path and quantifier).
+ * 
+ * @author Nourhan Zakaria
+ * @version 2.00 18/6/2014
+ */
+package sneps.network.classes;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.BitSet;
+
+import sneps.exceptions.CustomException;
+import sneps.network.Network;
+import sneps.network.Node;
+import sneps.network.paths.Path;
+
+public class Relation implements Serializable {
+
+	public static Relation andAnt, ant, cq, arg, min, max, i, threshMax, thresh, action, obj, precondition, act, when,
+			whenever, doo, iff, effect, plan, goal, vars, suchthat, elsee, obj1, obj2, obj3, obj4, obj5, obj6, obj7,
+			obj8, obj9, obj10;
+
+	/**
+	 * the name (string) that should label any arc representing this relation. Any
+	 * relation in SNePS is uniquely identified by its name.
+	 */
+	private String name;
+
+	/**
+	 * the name of the semantic class that represents the semantic type of the nodes
+	 * that this relation can point to.
+	 */
+	private String type;
+
+	/**
+	 * the bitset that represents the decoration of the relation. It can be one
+	 * of 7 options: 
+	 * 'reducible' 100000
+	 * 'expandable' 010000
+	 * 'rotary' 001000
+	 * 'reversible' 000100
+	 * 'concatenate' 000010
+	 * 'symmetric' 000001
+	 * 'none' 000000
+	 */
+
+	private BitSet decoration = new BitSet(6);
+
+	/**
+	 * the number that represents the minimum number of nodes that this relation can
+	 * point to within a down-cable.
+	 */
+	private int limit;
+
+	/**
+	 * the path defined for this relation to be used in path-based inference.
+	 */
+	private Path path;
+
+	/**
+	 * a boolean that tells whether this relation is a quantifier relation (true if
+	 * the relation is a quantifier, and false otherwise).
+	 */
+	private boolean quantifier;
+
+	/**
+	 * The constructor of this class.
+	 * 
+	 * @param n
+	 *            a string representing the name of the relation
+	 * @param t
+	 *            a string representing the name of the semantic type of the nodes
+	 *            that this relation can point to.
+	 * @param a
+	 *            a vector representing the decoration of the relations. 'reduce'
+	 *            if the relation is reducible. 'expand' if the relation is
+	 *            expandable. 'none' if the relation is neither reducible nor
+	 *            expandable.
+	 * @param l
+	 *            an integer representing the limit of the relation.
+	 */
+	public Relation(String n, String t, BitSet a, int l) {
+		this.name = n;
+		this.type = t;
+		this.decoration = a;
+		this.limit = l;
+		this.path = null;
+		setQuantifier();
+	}
+
+	public Relation(String name, String type) {
+		this.name = name;
+		this.type = type;
+		this.decoration = null;
+		this.limit = 1;
+		this.path = null;
+		setQuantifier();
+
+	}
+	
+
+	/**
+	 * @return the name of the current relation.
+	 */
+	public String getName() {
+		return this.name;
+	}
+
+	/**
+	 * @return the name of the semantic type of the nodes that can be pointed to by
+	 *         the current relation.
+	 */
+	public String getType() {
+		return this.type;
+	}
+
+	/**
+	 * @return the decoration of the current relation. ('reduce', 'expand' or
+	 *         'none')
+	 */
+	public BitSet getDecoration() {
+		return this.decoration;
+	}
+
+	/**
+	 * @return the limit of the current relation.
+	 */
+	public int getLimit() {
+		return this.limit;
+	}
+
+	/**
+	 * @return the path defined for the current relation. (can return null if there
+	 *         is no defined path for the current relation).
+	 */
+	public Path getPath() {
+		return this.path;
+	}
+
+	/**
+	 * @param path
+	 *            a Path that will be defined for the current relation to be used in
+	 *            path-based inference.
+	 */
+	public void setPath(Path path) {
+		this.path = path;
+	}
+
+	/**
+	 * @return true if the current relation is a quantifier relation, and false
+	 *         otherwise.
+	 */
+	public boolean isQuantifier() {
+		return this.quantifier;
+	}
+
+	/**
+	 * This method sets the boolean quantifier to true if the name of the current
+	 * relation represents a quantifier relation.
+	 */
+	public void setQuantifier() {
+		if (name.equals("forall") || name.equals("min") || name.equals("max") || name.equals("thresh")
+				|| name.equals("threshmax") || name.equals("emin") || name.equals("emax") || name.equals("etot")
+				|| name.equals("pevb") || name.equals("vars")) {
+			this.quantifier = true;
+		}
+	}
+
+	/**
+	 * This method overrides the default equals method inherited from the Object
+	 * class.
+	 * 
+	 * @param obj
+	 *            an Object that is to be compared to the current relation to check
+	 *            whether they are equal.
+	 * 
+	 * @return true if the given object is an instance of the Relation class and has
+	 *         the same name as the current relation, and false otherwise.
+	 */
+	@Override
+	public boolean equals(Object obj) {
+		if (!obj.getClass().getSimpleName().equals("Relation"))
+			return false;
+		if (!this.name.equals(((Relation) obj).getName()))
+			return false;
+		return true;
+	}
+
+	/**
+	 * This method overrides the default toString method inherited from the Object
+	 * class.
+	 * 
+	 * @return a string representing the name of the current relation.
+	 */
+	@Override
+	public String toString() {
+		return this.name;
+	}
+	
+	public static BitSet setbit () {
+		BitSet iset = new BitSet(6);
+		for(int i = 0; i < 6; i++) {
+	        iset.set(i);
+	     }
+		return iset;
+	}
+	public static BitSet clearbit () {
+		BitSet iclear = new BitSet(6);
+		for(int i = 0; i < 6; i++) {
+			iclear.clear();
+	     }
+		return iclear;
+	}
+	
+	public static BitSet setbitx (int x) {
+		BitSet iset = new BitSet(6);
+	        iset.set(x);
+		return iset;
+	}
+	
+	public static BitSet clearbitx (int x) {
+		BitSet iclear = new BitSet(6);
+			iclear.clear(x);
+		return iclear;
+	}
+
+	public static void createDefaultRelations() {
+		andAnt = Network.defineRelation("&ant", "Proposition" , clearbit() , 1);
+		ant = Network.defineRelation("ant", "Proposition", clearbit(), 1);
+		cq = Network.defineRelation("cq", "Proposition", clearbit(), 1);
+		arg = Network.defineRelation("arg", "Proposition", clearbit(), 1);
+		min = Network.defineRelation("min", "Infimum", clearbit(), 1);
+		max = Network.defineRelation("max", "Infimum", clearbit(), 1);
+		i = Network.defineRelation("i", "Infimum", clearbit(), 1);
+		thresh = Network.defineRelation("thresh", "Infimum", clearbit(), 1);
+		threshMax = Network.defineRelation("threshmax", "Infimum", clearbit(), 1);
+
+		action = Network.defineRelation("action", "Action", clearbit(), 1);
+
+		obj = Network.defineRelation("obj", "Entity", clearbit(), 1);
+
+		obj1 = Network.defineRelation("obj1", "Entity", clearbit(), 1);
+		obj2 = Network.defineRelation("obj2", "Entity", clearbit(), 1);
+		obj3 = Network.defineRelation("obj3", "Entity", clearbit(), 1);
+		obj4 = Network.defineRelation("obj4", "Entity", clearbit(), 1);
+		obj5 = Network.defineRelation("obj5", "Entity", clearbit(), 1);
+		obj6 = Network.defineRelation("obj6", "Entity", clearbit(), 1);
+		obj7 = Network.defineRelation("obj7", "Entity", clearbit(), 1);
+		obj8 = Network.defineRelation("obj8", "Entity", clearbit(), 1);
+		obj9 = Network.defineRelation("obj9", "Entity", clearbit(), 1);
+		obj10 = Network.defineRelation("obj10", "Entity", clearbit(), 1);
+
+		precondition = Network.defineRelation("precondition", "Proposition", clearbit(), 1);
+		act = Network.defineRelation("act", "Act", clearbit(), 1);
+		doo = Network.defineRelation("do", "Act", clearbit(), 1);
+		iff = Network.defineRelation("if", "Proposition", clearbit(), 1);
+		when = Network.defineRelation("when", "Proposition", clearbit(), 1);
+		whenever = Network.defineRelation("whenever", "Proposition", clearbit(), 1);
+		plan = Network.defineRelation("plan", "Act", clearbit(), 1);
+		goal = Network.defineRelation("goal", "Proposition", clearbit(), 1);
+		effect = Network.defineRelation("effect", "Proposition", clearbit(), 1);
+		suchthat = Network.defineRelation("suchthat", "Proposition", clearbit(), 1);
+		vars = Network.defineRelation("vars", "Infimum", clearbit(), 1);
+		elsee = Network.defineRelation("else", "Act", clearbit(), 1);
+	}
+	
+	
+	public static void main(String[] args) {
+//		Relation aa = new Relation("bro", "Proposition",null, 1);
+//		System.out.println(setbit());
+//		System.out.println(clearbit());
+	}
+
 }
\ No newline at end of file
diff --git a/src/sneps/network/classes/setClasses/.DS_Store b/src/sneps/network/classes/setClasses/.DS_Store
new file mode 100644
index 00000000..5679fb4d
Binary files /dev/null and b/src/sneps/network/classes/setClasses/.DS_Store differ
diff --git a/src/sneps/network/classes/setClasses/NodeCollection.java b/src/sneps/network/classes/setClasses/NodeCollection.java
new file mode 100644
index 00000000..7a06295b
--- /dev/null
+++ b/src/sneps/network/classes/setClasses/NodeCollection.java
@@ -0,0 +1,264 @@
+package sneps.network.classes.setClasses;
+
+import java.util.ArrayList;
+//import java.awt.Graphics;
+//import java.awt.print.PageFormat;
+//import java.awt.print.Printable;
+//import java.awt.print.PrinterException;
+//import java.io.Serializable;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Vector;
+import sneps.network.Node;
+import sneps.network.classes.term.Term;
+
+public class NodeCollection  {
+
+	public Vector<Node> Vector_Nodes;
+	public LinkedList<Node> LinkedList_Nodes;
+	//public ArrayList<Node> ArrayList_Nodes;
+	
+	public NodeCollection() {	
+		Vector_Nodes = new Vector<Node>();
+		LinkedList_Nodes = new LinkedList<Node>();
+	}
+/////////////////*/////////////////  Vector Methods Start
+	public Node VectorgetNode(int index) {
+		return this.Vector_Nodes.get(index);
+	}
+	public void VectoraddNode(Node node) {
+		if (!this.Vector_Nodes.contains(node))
+			this.Vector_Nodes.add(node);
+	}
+	public int Vectorsize() {
+		return this.Vector_Nodes.size();
+	}
+	public void VectoraddAll(NodeCollection Vector_NodeCollection) {
+		for (int i = 0; i < Vector_NodeCollection.Vectorsize(); i++) {
+			this.VectoraddNode(Vector_NodeCollection.VectorgetNode(i));
+		}
+	}
+	public void VectorremoveNode(Node node) {
+		this.Vector_Nodes.remove(node);
+	}
+
+	public void Vectorclear() {
+		this.Vector_Nodes.clear();
+	}
+	
+	public boolean VectorisEmpty() {
+		return this.Vector_Nodes.isEmpty();
+	}
+	
+	public boolean Vectorcontains(Node node) {
+		return this.Vector_Nodes.contains(node);
+	}
+	public Vector<Node> VectorUnion(NodeCollection Vector_NodeCollection) {
+		NodeCollection unionCollection = new NodeCollection();
+		unionCollection.VectoraddAll(this);
+		unionCollection.VectoraddAll(Vector_NodeCollection);
+		return unionCollection.Vector_Nodes;
+	}
+	public Vector<Node> VectorIntersection(NodeCollection Vector_NodeCollection) {
+		NodeCollection intersectionCollection = new NodeCollection();
+		for (int i = 0; i < Vector_NodeCollection.Vectorsize(); i++) {
+			if (this.Vectorcontains(Vector_NodeCollection.VectorgetNode(i)))
+				intersectionCollection.VectoraddNode(Vector_NodeCollection.VectorgetNode(i));
+		}
+		return intersectionCollection.Vector_Nodes;
+	}
+	public Vector<Node> Vectordifference(NodeCollection Vector_NodeCollection) {
+		NodeCollection differenceCollection = new NodeCollection();
+		for (int i = 0; i < this.Vectorsize(); i++) {
+			if (!Vector_NodeCollection.Vectorcontains(this.VectorgetNode(i)))
+				differenceCollection.VectoraddNode(this.VectorgetNode(i));
+		}
+		return differenceCollection.Vector_Nodes;
+	}
+	public boolean Vectorequals(Object obj) {
+		if (!obj.getClass().getSimpleName().equals("NodeCollection"))
+			return false;
+
+		NodeCollection nodeCollection = (NodeCollection) obj;
+		if (this.Vector_Nodes.size() != nodeCollection.Vectorsize())
+			return false;
+		for (int i = 0; i < this.Vector_Nodes.size(); i++) {
+			if (!nodeCollection.Vectorcontains(this.Vector_Nodes.get(i)))
+				return false;
+		}
+		return true;
+	}
+	public Iterator<Node> Vectoriterator() {
+		return Vector_Nodes.iterator();
+	}
+	public String VectortoString() {
+		String s = "{";
+		for (int i = 0; i < this.Vector_Nodes.size(); i++) {
+			s += this.Vector_Nodes.get(i).toString();
+			if (i < this.Vector_Nodes.size() - 1)
+				s += " ";
+		}
+		s += "}";
+		return s;
+	}
+/////////////////*/////////////////  Vector Methods Ends
+	/*
+	 * 
+	 */
+/////////////////*/////////////////  LinkedList Methods Starts	
+	public Node LinkedListgetNode(int index) {
+		return this.LinkedList_Nodes.get(index);
+	}
+	public void LinkedListaddNode(Node node) {
+		if (!this.LinkedList_Nodes.contains(node))
+			this.LinkedList_Nodes.add(node);
+	}
+	public void LinkedListaddNode(int index ,Node node) {
+		if (!this.LinkedList_Nodes.contains(node))
+			this.LinkedList_Nodes.add(index ,node);
+	}
+	public int LinkedListsize() {
+		return this.LinkedList_Nodes.size();
+	}
+	public void LinkedListaddAll(NodeCollection LinkedList_NodeCollection) {
+		for (int i = 0; i < LinkedList_NodeCollection.LinkedListsize(); i++) {
+			this.LinkedListaddNode(LinkedList_NodeCollection.LinkedListgetNode(i));
+		}
+	}
+	public void LinkedListremoveNode(Node node) {
+		this.LinkedList_Nodes.remove(node);
+	}
+	public void LinkedListclear() {
+		this.LinkedList_Nodes.clear();
+	}
+	public boolean LinkedListisEmpty() {
+		return this.LinkedList_Nodes.isEmpty();
+	}
+	public boolean LinkedListcontains(Node node) {
+		return this.LinkedList_Nodes.contains(node);
+	}
+	public LinkedList<Node> LinkedListUnion(NodeCollection LinkedList_NodeCollection) {
+		NodeCollection unionCollection = new NodeCollection();
+		unionCollection.LinkedListaddAll(this);
+		unionCollection.LinkedListaddAll(LinkedList_NodeCollection);
+		return unionCollection.LinkedList_Nodes;
+	}
+	public LinkedList<Node> LinkedListIntersection(NodeCollection LinkedList_NodeCollection) {
+		NodeCollection intersectionCollection = new NodeCollection();
+		for (int i = 0; i < LinkedList_NodeCollection.LinkedListsize(); i++) {
+			if (this.LinkedListcontains(LinkedList_NodeCollection.LinkedListgetNode(i)))
+				intersectionCollection.LinkedListaddNode(LinkedList_NodeCollection.LinkedListgetNode(i));
+		}
+		return intersectionCollection.LinkedList_Nodes;
+	}
+	public LinkedList<Node> LinkedListdifference(NodeCollection LinkedList_NodeCollection) {
+		NodeCollection differenceCollection = new NodeCollection();
+		for (int i = 0; i < this.LinkedListsize(); i++) {
+			if (!LinkedList_NodeCollection.LinkedListcontains(this.LinkedListgetNode(i)))
+				differenceCollection.LinkedListaddNode(this.LinkedListgetNode(i));
+		}
+		return differenceCollection.LinkedList_Nodes;
+	}
+	public boolean LinkedListequals(Object obj) {
+		if (!obj.getClass().getSimpleName().equals("NodeCollection"))
+			return false;
+
+		NodeCollection nodeCollection = (NodeCollection) obj;
+		if (this.LinkedList_Nodes.size() != nodeCollection.LinkedListsize())
+			return false;
+		for (int i = 0; i < this.LinkedList_Nodes.size(); i++) {
+			if (!nodeCollection.LinkedListcontains(this.LinkedList_Nodes.get(i)))
+				return false;
+		}
+		return true;
+	}
+	public Iterator<Node> LinkedListiterator() {
+		return LinkedList_Nodes.iterator();
+	}
+	public String LinkedListtoString() {
+		String s = "{";
+		for (int i = 0; i < this.LinkedList_Nodes.size(); i++) {
+			s += this.LinkedList_Nodes.get(i).toString();
+			if (i < this.LinkedList_Nodes.size() - 1)
+				s += " ";
+		}
+		s += "}";
+		return s;
+	}
+	
+	public LinkedList<Node> LinkedListSubList (NodeCollection LinkedList_NodeCollection) {
+		
+		NodeCollection x = new NodeCollection();
+		
+		for(int i = 0; i < LinkedList_NodeCollection.LinkedListsize(); i++) {
+			for(int j = 0; j < this.LinkedList_Nodes.size(); j++) {
+				if((LinkedList_NodeCollection.LinkedListgetNode(i)) != (this.LinkedList_Nodes.get(j))) {
+					
+				}
+			}
+		}
+		return x.LinkedList_Nodes;
+		
+	}
+/////////////////*/////////////////  LinkedList Methods Ends
+/*
+* 
+*/
+	public int [] VectorToArray (Vector<Integer> a) {
+		
+		int length = a.size();
+		int [] array = new int [length];
+		for(int i=0; i<length;i++) {
+			array[i] = a.get(i);
+		}
+		return array;
+		
+	}
+	
+	public int [] LinkedListToArray (LinkedList<Integer> a) {
+		
+		int length = a.size();
+		int [] array = new int [length];
+		for(int i=0; i<length;i++) {
+			array[i] = a.get(i);
+		}
+		return array;
+		
+	}
+	
+	public static void main(String[] args) {
+		
+		NodeCollection nc = new NodeCollection();
+		Term t = new Term("Tarek") {};
+		Term tt = new Term("Mohamed") {};
+		Term ttt = new Term("ElWasseif") {};
+		Node x = new Node(t);
+		Node xx = new Node(tt);
+		Node xxx = new Node(ttt);
+		nc.LinkedListaddNode(x);
+		nc.LinkedListaddNode(xx);
+		nc.LinkedListaddNode(xxx);
+		
+		NodeCollection ncc = new NodeCollection();
+		Term t1 = new Term("Ahmed") {};
+		Term tt2 = new Term("Hassan") {};
+		Term ttt3 = new Term("Tarek") {};
+		Node x1 = new Node(t1);
+		Node xx2 = new Node(tt2);
+		Node xxx3 = new Node(ttt3);
+		ncc.LinkedListaddNode(x1);
+		ncc.LinkedListaddNode(xx2);
+		ncc.LinkedListaddNode(xxx3);
+		
+		//System.out.println("Union : " + nc.VectorUnion(ncc));
+		//System.out.println("Intersection : " + nc.VectorIntersection(ncc));
+		//System.out.println("Difference : " + nc.Vectordifference(ncc));
+		
+		//System.out.println("Union : " + nc.LinkedListUnion(ncc));
+		//System.out.println("Intersection : " + nc.LinkedListIntersection(ncc));
+		//System.out.println("Difference : " + nc.LinkedListdifference(ncc));
+		
+	}
+
+}
+