diff --git a/src/pathcomp/.gitignore b/src/pathcomp/.gitignore
index 48a680bf0f45eb556108c349bc45be896f4219aa..82fc0ca316f8863947b66c3f294444161902e79c 100644
--- a/src/pathcomp/.gitignore
+++ b/src/pathcomp/.gitignore
@@ -1 +1,4 @@
 backend/wireshark
+backend/*.o
+backend/pathComp
+backend/pathComp-dbg
diff --git a/src/pathcomp/backend/pathComp_sp.c b/src/pathcomp/backend/pathComp_sp.c
index 084fc14f36ebe2cd749319df80a756ffb125a655..6c48a8d1b386c741decd1bf68782ee47de3f4ff0 100644
--- a/src/pathcomp/backend/pathComp_sp.c
+++ b/src/pathcomp/backend/pathComp_sp.c
@@ -144,7 +144,7 @@ void computation_shortest_path(struct service_t* s, struct compRouteOutput_t* pa
 	DEBUG_PC("Computed Path Avail Bw: %f, Path Cost: %f, latency: %f", p->availCap, p->cost, p->delay);
 	print_path(p);
 
-	gboolean feasibleRoute = check_computed_path_feasability(s, p);
+	gboolean feasibleRoute = check_computed_path_feasibility(s, p);
 	if (feasibleRoute == TRUE) {
 		DEBUG_PC("SP Feasible");
 		print_path(p);
diff --git a/src/pathcomp/backend/pathComp_tools.c b/src/pathcomp/backend/pathComp_tools.c
index 8fbef0476c86e655cc4f65fbac8aee2a05046cf9..321821f45ea54d1208fd0fa32b3c2f8201616b38 100644
--- a/src/pathcomp/backend/pathComp_tools.c
+++ b/src/pathcomp/backend/pathComp_tools.c
@@ -1460,8 +1460,7 @@ void modify_targeted_graph (struct graph_t *g, struct path_set_t *A, struct comp
  *	@date 2022
  */
 /////////////////////////////////////////////////////////////////////////////////////////
-gint find_nodeId (gconstpointer data, gconstpointer userdata)
-{
+gint find_nodeId (gconstpointer data, gconstpointer userdata) {
      /** check values */
      g_assert(data != NULL);
      g_assert(userdata != NULL);
@@ -1471,8 +1470,7 @@ gint find_nodeId (gconstpointer data, gconstpointer userdata)
      
      //DEBUG_PC ("SNodeId (%s) nodeId (%s)", SNodeId->node.nodeId, nodeId);   
         
-     if (!memcmp(SNodeId->node.nodeId, nodeId, strlen (SNodeId->node.nodeId)))
-     {
+     if (!memcmp(SNodeId->node.nodeId, nodeId, strlen (SNodeId->node.nodeId))) {
 		return (0);
      }
     return -1;
@@ -1501,13 +1499,13 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc
 	g_assert(g); g_assert(s); g_assert(mapNodes);
 
 	struct targetNodes_t *v = &(g->vertices[indexGraphU].targetedVertices[indexGraphV]);	
-    DEBUG_PC("Explored Link %s => %s)", u->node.nodeId, v->tVertice.nodeId);
+    DEBUG_PC("=======================CHECK Edge %s => %s =================================", u->node.nodeId, v->tVertice.nodeId);
 	//DEBUG_PC("\t %s => %s", u->node.nodeId, v->tVertice.nodeId);	
     
     // v already explored in S? then, discard it
     GList *found = g_list_find_custom (*S, v->tVertice.nodeId, find_nodeId);
     if (found != NULL) {
-        DEBUG_PC ("v (%s) in S, Discard", v->tVertice.nodeId);        
+        DEBUG_PC ("%s in S, DISCARD", v->tVertice.nodeId);        
         return 0;
     }
 
@@ -1524,10 +1522,11 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc
 		DEBUG_PC("EDGE %s[%s] => %s[%s]", u->node.nodeId, e->aEndPointId, v->tVertice.nodeId, e->zEndPointId);
         //DEBUG_PC ("\t %s[%s] =>", u->node.nodeId, e->aEndPointId);
 		//DEBUG_PC("\t => %s[%s]", v->tVertice.nodeId, e->zEndPointId);
-		DEBUG_PC("\t AvailBw: %f, TotalBw: %f", edgeAvailBw, edgeTotalBw);
+		DEBUG_PC("\t Edge Att: AvailBw: %f, TotalBw: %f", edgeAvailBw, edgeTotalBw);
         // Check Service Bw constraint
-		if ((path_constraints->bw == TRUE) && (edgeAvailBw < path_constraints->bwConstraint))
+		if ((path_constraints->bw == TRUE) && (edgeAvailBw < path_constraints->bwConstraint)) {
 			continue;
+		}
 		else {
 			foundAvailBw = 1;
 			break;
@@ -1535,7 +1534,7 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc
     }
 	// BW constraint NOT MET, then DISCARD edge
     if ((path_constraints->bw == TRUE) && (foundAvailBw == 0)) {
-        DEBUG_PC ("AvailBw: %f < path_constraint: %f -- Discard Edge", edgeAvailBw, path_constraints->bwConstraint);
+       	DEBUG_PC ("Edge AvailBw: %f < path_constraint: %f -- DISCARD Edge", edgeAvailBw, path_constraints->bwConstraint);
 		g_free(path_constraints);
         return 0;    
     } 
@@ -1581,13 +1580,14 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc
 	if (arg & ENERGY_EFFICIENT_ARGUMENT) {
 		if (distance_through_u == v_map->distance) {
 			if (power_through_u > v_map->power) {
-				DEBUG_PC("Energy (src -> u + u -> v: %f (Watts) >Energy (src, v): %f (Watts)--> DISCARD LINK", power_through_u, v_map->power);
+				DEBUG_PC("Energy (src -> u + u -> v: %f (Watts) > Energy (src, v): %f (Watts) --> DISCARD EDGE", power_through_u, v_map->power);
 				return 0;
 			}
 			// same energy consumption, consider latency
 			if ((power_through_u == v_map->power) && (latency_through_u > v_map->latency)) {
 				return 0;
 			}
+			// same energy, same latency, criteria: choose the one having the largest available bw
 			if ((power_through_u == v_map->power) && (latency_through_u == v_map->latency) && (availBw_through_u < v_map->avaiBandwidth)) {
 				return 0;
 			}
@@ -1604,8 +1604,9 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc
 			return 0;
 		}
 	}
-    DEBUG_PC ("%s --> %s Relaxed", u->node.nodeId, v->tVertice.nodeId);
-    DEBUG_PC ("\t AvailBw: %f Mb/s, Cost: %f, Latency: %f ms, Energy: %f Watts", availBw_through_u, distance_through_u, latency_through_u, power_through_u);
+   	DEBUG_PC ("Edge %s --> %s [RELAXED]", u->node.nodeId, v->tVertice.nodeId);
+    DEBUG_PC ("\t path till %s: AvailBw: %f Mb/s | Cost: %f | Latency: %f ms | Energy: %f Watts", v->tVertice.nodeId, availBw_through_u, distance_through_u,
+																latency_through_u, power_through_u);
     
     // Update Q list -- 
     struct nodeItem_t *nodeItem = g_malloc0 (sizeof (struct nodeItem_t));
@@ -1622,8 +1623,9 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc
 	if (arg & ENERGY_EFFICIENT_ARGUMENT) {
 		*Q = g_list_insert_sorted(*Q, nodeItem, sort_by_energy);
 	}
-	else
+	else {
 		*Q = g_list_insert_sorted (*Q, nodeItem, sort_by_distance);
+	}
     
 	// Update the mapNodes for the specific reached tv   
     v_map->distance = distance_through_u;
@@ -1635,9 +1637,9 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc
 	struct edges_t *e1 = &(v_map->predecessor);
 	struct edges_t *e2 = &(v->edges[indexEdge]);
 	duplicate_edge(e1, e2);	
-	DEBUG_PC ("u->v Edge: %s(%s) --> %s(%s)", e2->aNodeId.nodeId, e2->aEndPointId, e2->zNodeId.nodeId, e2->zEndPointId);
+	//DEBUG_PC ("u->v Edge: %s(%s) --> %s(%s)", e2->aNodeId.nodeId, e2->aEndPointId, e2->zNodeId.nodeId, e2->zEndPointId);
 	//DEBUG_PC("v-pred aTopology: %s", e2->aTopologyId);
-	DEBUG_PC("v-pred zTopology: %s", e2->zTopologyId);
+	//DEBUG_PC("v-pred zTopology: %s", e2->zTopologyId);
 
     // Check whether v is dstPEId
 	//DEBUG_PC ("Targeted dstId: %s", s->service_endpoints_id[1].device_uuid);
@@ -1659,7 +1661,7 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc
  *	@date 2022
  */
 /////////////////////////////////////////////////////////////////////////////////////////
-gboolean check_computed_path_feasability (struct service_t *s, struct compRouteOutputItem_t* p) {	
+gboolean check_computed_path_feasibility (struct service_t *s, struct compRouteOutputItem_t* p) {	
 	float epsilon = 0.0000001;
 	struct path_constraints_t* pathCons = get_path_constraints(s);
 	gboolean ret = TRUE;
@@ -2346,7 +2348,7 @@ void build_contextSet_linklList(GList** set, gint activeFlag) {
 	// for each link in linkList:
 	// 1st- Retrieve endpoints A --> B feauture (context Id, device Id, endpoint Id)
 	// 2st - In the graph associated to the contextId, check wheter A (deviceId) is in the vertices list
-	// o No, this is weird ... exist
+	// o No, this is weird ... exit
 	// o Yes, get the other link endpoint (i.e., B) and check whether it exists. If NOT add it, considering
 	// all the attributes; Otherwise, check whether the link is different from existing edges between A and B
 	gdouble epsilon = 0.1;
@@ -3065,7 +3067,7 @@ void dijkstra(gint srcMapIndex, gint dstMapIndex, struct graph_t* g, struct serv
 
 			// if ingress of the root link (aNodeId) is the spurNode, then stops
 			if (compare_node_id(&re->aNodeId, SN) == 0) {
-				DEBUG_PC("root Link: aNodeId: %s and spurNode: %s -- stop exploring the rootPath (RP)", re->aNodeId.nodeId, SN->nodeId);
+				DEBUG_PC("Ingress Node rootLink %s = spurNode %s; STOP exploring rootPath (RP)", re->aNodeId.nodeId, SN->nodeId);
 				break;
 			}
 			// Extract from Q
@@ -3073,7 +3075,6 @@ void dijkstra(gint srcMapIndex, gint dstMapIndex, struct graph_t* g, struct serv
 			struct nodeItem_t* node = (struct nodeItem_t*)(listnode->data);
 			Q = g_list_remove(Q, node);
 
-			//DEBUG_RL_RA ("Exploring node %s", node->node.nodeId);
 			indexVertice = graph_vertice_lookup(node->node.nodeId, g);
 			g_assert(indexVertice >= 0);
 
@@ -3087,22 +3088,21 @@ void dijkstra(gint srcMapIndex, gint dstMapIndex, struct graph_t* g, struct serv
 		}
 		// Check that the first node in Q set is SpurNode, otherwise something went wrong ...
 		if (compare_node_id(&re->aNodeId, SN) != 0) {
-			//DEBUG_PC ("root Link: aNodeId: %s is NOT the spurNode: %s -- something wrong", re->aNodeId.nodeId, SN->nodeId);
+			DEBUG_PC ("root Link: aNodeId: %s is NOT the spurNode: %s -- something wrong", re->aNodeId.nodeId, SN->nodeId);
 			g_list_free_full(g_steal_pointer(&S), g_free);
 			g_list_free_full(g_steal_pointer(&Q), g_free);
 			return;
 		}
 	}
-
 	while (g_list_length(Q) > 0) {
 		//Extract from Q set
 		GList* listnode = g_list_first(Q);
 		struct nodeItem_t* node = (struct nodeItem_t*)(listnode->data);
 		Q = g_list_remove(Q, node);
 		DEBUG_PC("Q length: %d", g_list_length(Q));
-		DEBUG_PC("DeviceId: %s", node->node.nodeId);
+		DEBUG_PC("Explored DeviceId: %s", node->node.nodeId);
 
-		// visit all the links from u within the graph
+		// scan all the links from u within the graph
 		indexVertice = graph_vertice_lookup(node->node.nodeId, g);
 		g_assert(indexVertice >= 0);
 
@@ -3140,18 +3140,19 @@ gint ksp_comp(struct pred_t* pred, struct graph_t* g, struct service_t* s,
 	struct map_nodes_t* mapNodes, guint arg) {
 	g_assert(pred); g_assert(g); g_assert(s);
 
-	DEBUG_PC("Source: %s -- Destination: %s", s->service_endpoints_id[0].device_uuid, s->service_endpoints_id[1].device_uuid);
+	DEBUG_PC("SOURCE: %s --> DESTINATION: %s", s->service_endpoints_id[0].device_uuid, 
+								s->service_endpoints_id[1].device_uuid);
 
 	// Check the both ingress src and dst endpoints are in the graph
 	gint srcMapIndex = get_map_index_by_nodeId(s->service_endpoints_id[0].device_uuid, mapNodes);
 	if (srcMapIndex == -1) {
-		DEBUG_PC("ingress DeviceId: %s NOT in the graph", s->service_endpoints_id[0].device_uuid);
+		DEBUG_PC("ingress DeviceId: %s NOT in G", s->service_endpoints_id[0].device_uuid);
 		return -1;
 	}
 	
 	gint dstMapIndex = get_map_index_by_nodeId(s->service_endpoints_id[1].device_uuid, mapNodes);
 	if (dstMapIndex == -1) {
-		DEBUG_PC("egress DeviceId: %s NOT in the graph", s->service_endpoints_id[1].device_uuid);
+		DEBUG_PC("egress DeviceId: %s NOT in G", s->service_endpoints_id[1].device_uuid);
 		return -1;
 	}
 
@@ -3165,17 +3166,17 @@ gint ksp_comp(struct pred_t* pred, struct graph_t* g, struct service_t* s,
 	gint map_dstIndex = get_map_index_by_nodeId(s->service_endpoints_id[1].device_uuid, mapNodes);
 	struct map_t* dest_map = &mapNodes->map[map_dstIndex];
 	if (!(dest_map->distance < INFINITY_COST)) {
-		DEBUG_PC("destination: %s NOT reachable", s->service_endpoints_id[1].device_uuid);
+		DEBUG_PC("DESTINATION: %s NOT reachable", s->service_endpoints_id[1].device_uuid);
 		return -1;
 	}
 
 	DEBUG_PC("AvailBw @ %s is %f", dest_map->verticeId.nodeId, dest_map->avaiBandwidth);
 	// Check that the computed available bandwidth is larger than 0.0
 	if (dest_map->avaiBandwidth <= (gfloat)0.0) {
-		DEBUG_PC("dst: %s NOT REACHABLE", s->service_endpoints_id[1].device_uuid);
+		DEBUG_PC("DESTINATION %s NOT REACHABLE", s->service_endpoints_id[1].device_uuid);
 		return -1;
 	}
-	DEBUG_PC("dst: %s REACHABLE", s->service_endpoints_id[1].device_uuid);
+	DEBUG_PC("DESTINATION %s REACHABLE", s->service_endpoints_id[1].device_uuid);
 	// Handle predecessors
 	build_predecessors(pred, s, mapNodes);
 	return 1;
@@ -3229,6 +3230,9 @@ void alg_comp(struct service_t* s, struct compRouteOutput_t* path, struct graph_
 	struct service_endpoints_id_t* iEp = &(s->service_endpoints_id[0]);
 	struct service_endpoints_id_t* eEp = &(s->service_endpoints_id[1]);
 
+	DEBUG_PC("=======================================================================================");
+	DEBUG_PC("STARTING PATH COMP FOR %s[%s] --> %s[%s]", iEp->device_uuid, iEp->endpoint_uuid, eEp->device_uuid, eEp->endpoint_uuid);
+
 	// Compute the 1st KSP path
 	gint done = ksp_comp(predecessors, g, s, NULL, NULL, mapNodes, arg);
 	if (done == -1) {
@@ -3360,9 +3364,10 @@ void alg_comp(struct service_t* s, struct compRouteOutput_t* path, struct graph_
 	// copy the service endpoints, in general, there will be 2 (point-to-point network connectivity services)
 	for (gint m = 0; m < s->num_service_endpoints_id; m++) {
 		struct service_endpoints_id_t* iEp = &(s->service_endpoints_id[m]);
-		struct service_endpoints_id_t* oEp = &(s->service_endpoints_id[m]);
+		struct service_endpoints_id_t* oEp = &(path->service_endpoints_id[m]);
 		copy_service_endpoint_id(oEp, iEp);
 	}
+	path->num_service_endpoints_id = s->num_service_endpoints_id;
 
 	// Print all the paths i A
 	for (gint h = 0; h < A->numPaths; h++) {
@@ -3376,9 +3381,10 @@ void alg_comp(struct service_t* s, struct compRouteOutput_t* path, struct graph_
 			DEBUG_PC("Number Requested paths (%d) REACHED - STOP", ksp);
 			break;
 		}
-		gdouble feasibleRoute = check_computed_path_feasability(s, &A->paths[ksp]);
+		gdouble feasibleRoute = check_computed_path_feasibility(s, &A->paths[ksp]);
 		if (feasibleRoute == TRUE) {
-			DEBUG_PC("A[%d] available: %f, pathCost: %f; latency: %f, Power: %f", ksp, A->paths[ksp].availCap, A->paths[ksp].cost, A->paths[ksp].delay, A->paths[ksp].power);
+			DEBUG_PC("A[%d] available: %f, pathCost: %f; latency: %f, Power: %f", ksp, A->paths[ksp].availCap, 
+											A->paths[ksp].cost, A->paths[ksp].delay, A->paths[ksp].power);
 			struct compRouteOutputItem_t* pathaux = &A->paths[ksp];
 			path->numPaths++;
 			struct path_t* targetedPath = &path->paths[path->numPaths - 1];
diff --git a/src/pathcomp/backend/pathComp_tools.h b/src/pathcomp/backend/pathComp_tools.h
index f69de1836520cd654ba0b59f72c17a80c6a6758f..9819c9080486f37cba531791cc20d10b04cb54e1 100644
--- a/src/pathcomp/backend/pathComp_tools.h
+++ b/src/pathcomp/backend/pathComp_tools.h
@@ -39,7 +39,7 @@ extern GList* activeServList;
 #define INFINITY_COST                   0xFFFFFFFF
 #define MAX_NUM_PRED					100
 
-#define MAX_KSP_VALUE					3
+#define MAX_KSP_VALUE					5
 
 // HTTP RETURN CODES
 #define HTTP_CODE_OK					200
@@ -576,7 +576,7 @@ gboolean matching_path_rootPath (struct compRouteOutputItem_t *, struct compRout
 void modify_targeted_graph (struct graph_t *, struct path_set_t *, struct compRouteOutputItem_t *, struct nodes_t *);
 gint find_nodeId (gconstpointer, gconstpointer);
 gint check_link (struct nodeItem_t *, gint, gint, struct graph_t *, struct service_t *, GList **, GList **, struct map_nodes_t *, guint arg);
-gboolean check_computed_path_feasability (struct service_t *, struct compRouteOutputItem_t * );
+gboolean check_computed_path_feasibility (struct service_t *, struct compRouteOutputItem_t * );
 
 gint sort_by_distance (gconstpointer, gconstpointer);
 gint sort_by_energy(gconstpointer, gconstpointer);