diff --git a/Code/mp2.h b/Code/mp2.h
index 8eb343e87ff8cfc16f086854df49bae947a84813..db4e49fe4aed52a114c029d40a59a611cf1a452f 100755
--- a/Code/mp2.h
+++ b/Code/mp2.h
@@ -31,6 +31,20 @@ int total_segments = 0; // store total trace number
 clock_t gen_start, gen_end;	// for time measurement 
 double	dif;				// time interval 
 
+static int cp_attempts = 0;
+static int cp_success = 0;
+static int cp_failed = 0;
+static int cp_failedarfn = 0;
+static int cp_successarfn = 0;
+
+static int perm_attempts = 0;
+static int perm_success = 0;
+static int perm_failed = 0;
+static int perm_failedarfn = 0;
+static int perm_successarfn = 0;
+
+static int fw_cycles = 0;
+
 //************************
 //***** Globals 
 //************************
@@ -204,9 +218,9 @@ string event_type_string[] = {	"Atom",	"Composite_producer_node",
 								"simple_or_IF_op", "SAY_message" };
 
 //======= traversal results
-enum Traversal_result {failed, success_and_completed, success_and_ready_for_next};
+enum Traversal_result {failed, success_and_completed, success_and_ready_for_next, failed_and_ready_for_next};
 string Traversal_result_string[] = {"failed", "success_and_completed", 
-									"success_and_ready_for_next"};
+									"success_and_ready_for_next", "failed_and_ready_for_next"};
 	
 //*****************************************************************
 // for layout calculation in Composite_producer::output_JSON()
@@ -302,10 +316,12 @@ Traversal_result get_permutation(vector<int> &result){
                 return previous_Traversal_result;
         }
         else { // no hold
+		perm_attempts++;
             switch(previous_Traversal_result){
             
-                case success_and_completed:
-                case failed:      // this case is taken at the initial call only              
+                case success_and_completed: perm_success++;
+                case failed:      // this case is taken at the initial call only 
+												if (previous_Traversal_result == failed) perm_failed++;             
                                                 reset();
                                                 work = result;
                                                 // recalculate N!
@@ -313,8 +329,9 @@ Traversal_result get_permutation(vector<int> &result){
                                                 for(int i = 1; i <= result.size(); i++) total_max *= i;
                                                 sort(work.begin(), work.end());// required by next_permutation()
                                                 break;
-                    
+                case failed_and_ready_for_next: perm_failedarfn++;
                 case success_and_ready_for_next:    was_on_hold =   false;
+					if (previous_Traversal_result == success_and_ready_for_next) perm_successarfn++;
                                                     // and proceed with the next permutation                 
             } // end switch
         }// end else - ! hold
@@ -339,8 +356,12 @@ Traversal_result get_permutation(vector<int> &result){
                 hold = false;
                 was_on_hold = true;
             }
-            else    was_on_hold = false;
-                        
+            else {   was_on_hold = false;
+            //if (previous_Traversal_result == failed_and_ready_for_next) {
+			//	previous_Traversal_result = failed;
+			//	throw failed;
+			//}
+			}
             return (previous_Traversal_result = success_and_completed);
         }
     } // end get_permutation()
@@ -464,6 +485,8 @@ public:
         int successful_alternative;
 		for(int i = current_alternative; (i < element_count) && !done; i++){
 			switch(result = (element[i] -> traverse()) ){
+				case failed_and_ready_for_next:
+					//printf("HIT OR NODE CONTAINER\n");
 				case failed:				continue; // try next alternative
 					
 				case success_and_completed:	current_alternative++;
@@ -509,8 +532,8 @@ public:
 	AND_node_producer_container(int n): Event_producer(n){
 		type = target_event = AND_node;
 	} 
-	
-	Traversal_result traverse(){ 
+	//TRAVERSE
+	Traversal_result traverse(){
 
 		completeness_count = 0;
 		for(int i =0; i< element_count; i++){
@@ -519,20 +542,28 @@ public:
 				// before element[i] -> traverse()
 				predecessor.back() = -1; // block regular ordering
 			}			
-			
+			cp_attempts++;
 			switch(element[i] -> traverse()){
 				case failed:					if(completeness_count == i) 
 													// there are no more options to try
 													// let harvest() to stop calling this traverse() again
 													completeness_count = element_count;
+												cp_failed++;
 												return failed; 
 					
 				case success_and_completed:		completeness_count++;
+												cp_success++;
 												break;
 					
+				case failed_and_ready_for_next:
+				//printf("");
+													for(int j = 0; j<i; j++) 
+														element[j]->hold();
+												cp_failedarfn++;
+												return failed;
 				case success_and_ready_for_next:
 					// hold all previous nodes until element[i] completes
-                    
+												cp_successarfn++;
                                                 for(int j = 0; j<i; j++) 
 													element[j]->hold(); 
 			};
@@ -632,7 +663,13 @@ public:
 				case success_and_ready_for_next:
 					// hold all previous OR_nodes until element[i] completes
 					for(int j = 0; j<i; j++) 
-						element[j]->hold(); 
+						element[j]->hold();
+					break;
+				case failed_and_ready_for_next:
+				//printf("SET FAILEDARFN\n");
+					for(int j = 0; j<i; j++) 
+						element[j]->hold();
+					return failed;
 			}
 			//===============================
 			// after element[i] -> traverse()
@@ -971,7 +1008,7 @@ public:
 		}
 		// check for loops: axioms 5-6
 		for(int i = 0; i < len; i++){
-			if(m[i * len + i]) throw failed;
+			if(m[i * len + i]) throw failed_and_ready_for_next;
 		}
 	} // end in_transitive_closure(char * m)
 	
@@ -1015,7 +1052,11 @@ public:
 		}
 		// check for loops: axioms 5-6
 		for(int i = 0; i < len; i++){
-			if(m[i * len + i]) throw failed;
+			if(m[i * len + i]) {
+				//printf("cycle\n");
+				fw_cycles++;
+				throw failed_and_ready_for_next;
+			}
 		}
 		// check for mutual exclusion: axioms 1-4
 		for(int k = 0; k < len; k++){