AbstractIntegratedModule 1.0.4__tar.gz → 1.0.6__tar.gz

{abstractintegratedmodule-1.0.4 → abstractintegratedmodule-1.0.6}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.0.4
+Version: 1.0.6
 Summary: Integrated Pipeline with Specialized Non-LLM AI Agent Framework for ARM64 architecture
 Author: Micro-Novelty
 Author-email: Micro-Novelty <hernikpuspita5@gmail.com>

{abstractintegratedmodule-1.0.4 → abstractintegratedmodule-1.0.6}/AbstractIntegratedModule.py

@@ -1868,7 +1868,7 @@ class MLP:
                                standard_low_error_mean + standard_pred_quality)
 
         if np.isnan(performance_score) or np.isinf(performance_score):
-            performance_score = 0.5
+            performance_score = 0.15
 
         return performance_score
 
@@ -2296,7 +2296,7 @@ class LSTMNetwork:
 
         diff = preds - targets
         loss = (1.0 - AMR) * np.mean(diff ** 2)
-        dloss = diff / (min_T * min_F)   # FIX 3 — normalize by full element count
+        dloss = diff / (min_T * min_F)   # normalized by full element count
         return loss, dloss
 
     # backward method for the network to calculate proper weights with cell backward
@@ -5123,7 +5123,7 @@ class ModelStorage:
             repaired = {}
             for key, value in data.items():
 
-                # dynamic corruption check instead of hardcoded 133
+                # dynamic corruption check 
                 if isinstance(value, list):
                     arr = np.asarray(value)
                     if arr.ndim > 2:
@@ -5137,7 +5137,7 @@ class ModelStorage:
                             f'{arr.shape}, expected {num_classes} — removing')
                         continue
 
-                # None values — skip silently
+                # None values — skipped silently
                 if value is None:
                     continue
 
@@ -16996,201 +16996,229 @@ class PipelinePredictionManager:
             if isinstance(confidence, (np.ndarray, list)):
                 confidence = np.mean(confidence)
 
-            print(f"\n[🎯] Initial chosen label for input: {chosen_label} || Confidence: {confidence:.1%}")
+            return_single_condition = (
+                not self.pipeline.use_transformer or
+                not need_ensemble_method 
 
-            if results[0].get('models_agree', True) and confidence > self.pipeline.confidence_threshold and not chosen_label.startswith("unknown"):
-                print(f"\n[🎯] Proper Confidence of Final chosen label for input: {chosen_label} || Confidence: {confidence:.1%}")
-                return results, chosen_label, confidence
-            
-            # Only recalibrate if models disagreed
-            elif results and not results[0].get('models_agree', True) or not self.pipeline.agreement:
-                need_peer_condition = not results[0].get('models_agree', True) and self.pipeline.peer_assistance_threshold > 0.3
-                print("\n[⚠️] Disagreement detected between MLP and Transformer predictions. Using calibrated probabilities for final decision.")
-                if not self.pipeline.autonomous and need_peer_condition:
-                    print('|| Uncertain advanced prediction, requesting peer assistance if allowed...')
-                    final_probs = self.pipeline._handle_distributed_connections(final_probs, attn_weights, input_ids, agreement) 
-
-                    final_idx = final_probs[0].argmax()
-                    original_idx = final_idx
-
-                    if final_idx > len(reverse_map):
-                        final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                        print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
-                    final_idx = int(final_idx)  
-
-                    chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                    if chosen_label.startswith('unknown'):
-                        final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-
-                    try:
-                        print(final_probs)
-                        confidence = float(final_probs[final_idx])   
-                    except:
-                        confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0      
-                        
-                elif self.pipeline.autonomous and need_peer_condition and attn_weights is not None:
-                    if agreement is None:
-                        agreement = False
-
-                    print('[||] Iniating local peer output search in database for best output...')
-                    final_probs = self.pipeline.distribution._handle_peer_agent_request(final_probs, attn_weights, input_ids, type='DevicePeer', agreement=agreement)
+            )
+            if return_single_condition:
+                print('[=] Displaying Results....')
+                if not results[0].get('models_agree', True) and self.pipeline.use_transformer:
+                    trans_confidence = results[0].get('trans_confidence', 1e-8)
+                    confidence = (confidence + trans_confidence / 2) + 1e-5
+                    print(f'[=] Calibrating confidence around: {confidence:.1%} Due to disagreement between Transformer and MLP.')
+                    
+                if isinstance(chosen_label, str) and chosen_label.startswith("unknown") or float(confidence) < self.pipeline.confidence_threshold:
+                    if chosen_label is None or chosen_label.startswith('unknown'):
+                        chosen_label = 'Unknown'
+                        confidence = 1.0 - confidence  #Invert confidence for unknown class
+                        print(f"\n[⚠️] Final prediction is {chosen_label} with uncertain confidence: {confidence:.1%}. Consider more consistent data for the model to learn from.")
+                    else:
+                        print(f"\n[🎯] Predicted label: {chosen_label} || With Certain Confidence: {confidence:.1%}")
 
-                    final_idx = final_probs[0].argmax()
-                    original_idx = final_idx              
+                payload = {
+                    'X_samples': X,
+                    'input_ids': input_ids
+                }
+                if titles is not None and len(titles) > 0:
+                    correct, sec_correct = self.display_hybrid_results(payload, final_class_idx, results, top_k, verbose=True)
 
-                    if final_idx > len(reverse_map):
-                        final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                        print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
-                    final_idx = int(final_idx)  
+                return results, chosen_label, confidence
 
-                    chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                    try:
-                        confidence = float(final_probs[final_idx])   
-                    except:
-                        confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0      
+            else:
+                if results[0].get('models_agree', True) and confidence > self.pipeline.confidence_threshold and not chosen_label.startswith("unknown"):
+                    print(f"\n[🎯] Proper Confidence of Final chosen label for input: {chosen_label} || Confidence: {confidence:.1%}")
+                    return results, chosen_label, confidence
+                    
+                # Only recalibrate if models disagreed
+                elif results and not results[0].get('models_agree', True) or not self.pipeline.agreement and self.pipeline.use_transformer:
 
+                    need_peer_condition = not results[0].get('models_agree', True) and self.pipeline.peer_assistance_threshold > 0.3 and self.pipeline.use_transformer
+                    print("\n[⚠️] Disagreement detected between MLP and Transformer predictions. Usig calibrated probabilities for final decision.")
+                    if confidence < self.pipeline.confidence_threshold and need_peer_condition:
+                        print('|| Uncertain advanced prediction, requesting peer assistance if allowed...')
+                        final_probs = self.pipeline._handle_distributed_connections(final_probs, attn_weights, input_ids, agreement) 
 
-                elif not results[0].get('models_agree', True) and confidence > self.pipeline.confidence_threshold:
-                    if final_confidence is not None and confidence < self.pipeline.confidence_threshold:
-                        print("\n[⚠️] Low confidence detected, but both models don't agree. Using calibrated probabilities for final decision to ensure robustness.")
-                        final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset, X=X, y=y, use_embedded=use_embedded)
-                      
                         final_idx = final_probs[0].argmax()
                         original_idx = final_idx
-                        
+
                         if final_idx > len(reverse_map):
                             final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
                             print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
                         final_idx = int(final_idx)  
-                    else:
-                        print('[🎯] Stable confidence established, But both Models doesnt Agree, Re-evaluating...')   
-                        final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset, X=X, y=y, use_embedded=use_embedded)
-                      
-                        final_idx = final_probs[0].argmax()
-                        original_idx = final_idx
-                        if final_idx > len(reverse_map):
+
+                        chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
+                        if chosen_label.startswith('unknown'):
                             final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                            print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
-                        final_idx = int(final_idx)    
 
-                    chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                    try:
-                        confidence = float(final_probs[0][final_idx])   
-                    except:
-                        confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
-                else:
-                    if self.pipeline.use_transformer and need_ensemble_method:
-                        print("\n[⚠️] Uncertain confidence and disagreement detected. Using ensemble method for final decision.")
-                        input_forward = sequence_ids if sequence_ids is not None else input_ids
-                        final_probs, details = self.pipeline.ensemble.predict_ensemble(input_forward, X, y, method='dynamic', embedded=use_embedded)
-                    
+                        try:
+                            confidence = float(final_probs[final_idx])   
+                        except:
+                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0      
+               
+                    elif self.pipeline.autonomous and need_peer_condition and attn_weights is not None:
+                        if agreement is None:
+                            agreement = False
+
+                        print('[||] Iniating local peer output search in database for best output...')
+                        final_probs = self.pipeline.distribution._handle_peer_agent_request(final_probs, attn_weights, input_ids, type='DevicePeer', agreement=agreement)
+
                         final_idx = final_probs[0].argmax()
-                        original_idx = final_idx 
+                        original_idx = final_idx              
 
                         if final_idx > len(reverse_map):
                             final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
                             print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
-                        final_idx = int(final_idx)          
+                        final_idx = int(final_idx)  
 
                         chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
                         try:
-                            confidence = float(final_probs[0][final_idx])   
+                            confidence = float(final_probs[final_idx])   
                         except:
-                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
-                    else:
-                        if final_probs is None:
-                            final_probs = mlp_probs
+                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0      
 
-                        final_probs = self.calibration_penalized_check(final_probs, target_pred_indices[0])
 
-                        final_idx = final_probs[0].argmax() if final_probs is not None else target_probs[0].argmax()
+                    elif not results[0].get('models_agree', True) and confidence > self.pipeline.confidence_threshold:
+                        if final_confidence is not None and confidence < self.pipeline.confidence_threshold:
+                            print("\n[⚠️] Low confidence detected, but both models don't agree. Using calibrated probabilities for final decision to ensure robustness.")
+                            final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset, X=X, y=y, use_embedded=use_embedded)
                         
-                        original_idx = final_idx 
-
-                        if final_idx > len(reverse_map):
-                            final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                            print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
-                        final_idx = int(final_idx)          
+                            final_idx = final_probs[0].argmax()
+                            original_idx = final_idx
+                            
+                            if final_idx > len(reverse_map):
+                                final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
+                                print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
+                            final_idx = int(final_idx)  
+                        else:
+                            print('[🎯] Stable confidence established, But both Models doesnt Agree, Re-evaluating...')   
+                            final_probs = self.pipeline.hybrid_prediction(rules, input_ids, dataset, X=X, y=y, use_embedded=use_embedded)
+                        
+                            final_idx = final_probs[0].argmax()
+                            original_idx = final_idx
+                            if final_idx > len(reverse_map):
+                                final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
+                                print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
+                            final_idx = int(final_idx)    
 
                         chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                        if final_probs is None:
-                            final_probs = target_probs.copy()
-
                         try:
+                            confidence = float(final_probs[0][final_idx])   
+                        except:
+                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
+                    else:
+                        if self.pipeline.use_transformer and need_ensemble_method:
+                            print("\n[⚠️] Uncertain confidence and disagreement detected. Using ensemble method for final decision.")
+                            input_forward = sequence_ids if sequence_ids is not None else input_ids
+                            final_probs, details = self.pipeline.ensemble.predict_ensemble(input_forward, X, y, method='dynamic', embedded=use_embedded)
+                        
+                            final_idx = final_probs[0].argmax()
+                            original_idx = final_idx 
+
+                            if final_idx > len(reverse_map):
+                                final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
+                                print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
+                            final_idx = int(final_idx)          
+
+                            chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
                             try:
                                 confidence = float(final_probs[0][final_idx])   
                             except:
                                 confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
-                        except:
+                        else:
+                            if final_probs is None:
+                                final_probs = mlp_probs
+
+                            final_probs = self.calibration_penalized_check(final_probs, target_pred_indices[0])
+
+                            final_idx = final_probs[0].argmax() if final_probs is not None else target_probs[0].argmax()
+                            
+                            original_idx = final_idx 
+
+                            if final_idx > len(reverse_map):
+                                final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
+                                print(f"[⚠️] Clamping {final_idx} → {final_idx}")               
+                            final_idx = int(final_idx)          
+
+                            chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
+                            if final_probs is None:
+                                final_probs = target_probs.copy()
+
                             try:
-                                confidence = float(final_probs[final_idx]) 
+                                try:
+                                    confidence = float(final_probs[0][final_idx])   
+                                except:
+                                    confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
                             except:
-                                confidence = self.pipeline.confidence_threshold
+                                try:
+                                    confidence = float(final_probs[final_idx]) 
+                                except:
+                                    confidence = self.pipeline.confidence_threshold
 
-            elif confidence < self.pipeline.confidence_threshold and not self.pipeline.agreement and not results[0].get('models_agree', True):
-                if trans_probs is not None:
-                    prob_entropy = self.calculate_entropy(final_probs)
-                    normalized_entropy = prob_entropy / np.log(prob_entropy.shape[-1]) if prob_entropy.shape[-1] > 1 else 0
-                    attn_quality = 1.0 / (1.0 + np.exp(-attn_weights.mean()) + eps) if attn_weights is not None else 0.5
-                    anisotropy = self.pipeline.anisotropy_measurement(attn_weights.mean() if attn_weights is not None else 0.5)
+                elif confidence < self.pipeline.confidence_threshold and not self.pipeline.agreement and not results[0].get('models_agree', True):
+                    if trans_probs is not None:
+                        prob_entropy = self.calculate_entropy(final_probs)
+                        normalized_entropy = prob_entropy / np.log(prob_entropy.shape[-1]) if prob_entropy.shape[-1] > 1 else 0
+                        attn_quality = 1.0 / (1.0 + np.exp(-attn_weights.mean()) + eps) if attn_weights is not None else 0.5
+                        anisotropy = self.pipeline.anisotropy_measurement(attn_weights.mean() if attn_weights is not None else 0.5)
 
-                else:
-                    normalized_entropy = self.calculate_entropy(input_ids)  # Max entropy for uniform distribution
-                    attn_quality = self.pipeline.confidence_threshold
-                    anisotropy = self.anisotropy_measurement(input_ids) if hasattr(self.pipeline, 'anisotropy_measurement') else 0.5
-
-                mean_entropy = np.mean(normalized_entropy)
-
-                use_simple_prediction = (
-                anisotropy < 0.3 or
-                mean_entropy < 0.5 or  # High uncertainty
-                results[0].get('confidence', 0) < 0.4 or  # Low confidence
-                not results[0].get('models_agree', True) or  # Disagreement
-                attn_quality < 0.4
-                )
+                    else:
+                        normalized_entropy = self.calculate_entropy(input_ids)  # Max entropy for uniform distribution
+                        attn_quality = self.pipeline.confidence_threshold
+                        anisotropy = self.anisotropy_measurement(input_ids) if hasattr(self.pipeline, 'anisotropy_measurement') else 0.5
+
+                    mean_entropy = np.mean(normalized_entropy)
+
+                    use_simple_prediction = (
+                    anisotropy < 0.3 or
+                    mean_entropy < 0.5 or  # High uncertainty
+                    results[0].get('confidence', 0) < 0.4 or  # Low confidence
+                    not results[0].get('models_agree', True) or  # Disagreement
+                    attn_quality < 0.4
+                    )
+
+                    if use_simple_prediction:
+                        print("\n[⚡] Condition is poorly unviable to handle agreement. Using robust prediction method for better reliability.")
+                        predicted_label, confidence = self.simple_pass_prediction(self.pipeline, titles=titles, label_map=label_map, X_raw=X, y=y, show_proba=show_proba, top_k=top_k)
+                        if predicted_label is not None:
+                            print(f"\n[🎯] Robust prediction result: {predicted_label} with confidence {confidence:.1%}")
+                            return _, predicted_label, confidence
+
+                    else:
+                        final_idx = final_probs[0].argmax()
+                        original_idx = final_idx
 
-                if use_simple_prediction:
-                    print("\n[⚡] Condition is poorly unviable to handle agreement. Using robust prediction method for better reliability.")
-                    predicted_label, confidence = self.simple_pass_prediction(self.pipeline, titles=titles, label_map=label_map, X_raw=X, y=y, show_proba=show_proba, top_k=top_k)
-                    if predicted_label is not None:
-                        print(f"\n[🎯] Robust prediction result: {predicted_label} with confidence {confidence:.1%}")
-                        return _, predicted_label, confidence
+                        if final_idx > len(reverse_map):
+                            final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
+                            print(f"[⚠️] Clamping {final_idx} → {final_idx}")                      
+                        final_idx = int(final_idx) 
+
+                        chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
+                        if final_probs is not None:
+                            try:
+                                confidence = float(final_probs[0][final_idx])   
+                            except:
+                                confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0  
+            
+                        else:
+                            final_probs = target_probs.copy() 
 
                 else:
+                    print("\n[🎯] Using initial Regular final prediction as final decision.")
                     final_idx = final_probs[0].argmax()
-                    original_idx = final_idx
 
                     if final_idx > len(reverse_map):
                         final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                        print(f"[⚠️] Clamping {final_idx} → {final_idx}")                      
-                    final_idx = int(final_idx) 
+                        print(f"[⚠️] Clamping {final_idx} → {final_idx}")                    
+                    final_idx = int(final_idx)
 
                     chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-                    if final_probs is not None:
-                        try:
-                            confidence = float(final_probs[0][final_idx])   
-                        except:
-                            confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0  
-           
-                    else:
-                        final_probs = target_probs.copy() 
-
-            else:
-                print("\n[🎯] Using initial Regular final prediction as final decision.")
-                final_idx = final_probs[0].argmax()
-
-                if final_idx > len(reverse_map):
-                    final_idx = int(np.argmax(final_probs[:len(reverse_map)-1]))
-                    print(f"[⚠️] Clamping {final_idx} → {final_idx}")                    
-                final_idx = int(final_idx)
 
-                chosen_label = reverse_map.get(final_idx, f"unknown_{final_idx}")
-
-                try:
-                    confidence = float(final_probs[0][final_idx])   
-                except:
-                    confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
-            
+                    try:
+                        confidence = float(final_probs[0][final_idx])   
+                    except:
+                        confidence = float(final_probs[0][len(reverse_map)-1]) if isinstance(final_probs[0], (float, int)) else 0.0             
+                
             if confidence > 0.8:
                 confidence = (confidence + performance_score) / 2 
                 print(f'[⚡] Confidence calibrated to be around: {confidence}')
@@ -17198,7 +17226,7 @@ class PipelinePredictionManager:
             if isinstance(chosen_label, str) and chosen_label.startswith("unknown") or float(confidence) < self.pipeline.confidence_threshold:
                 if chosen_label.startswith("unknown"):
                     chosen_label = 'Unknown'
-                    confidence = 1.0 - confidence  # Invert confidence for unknown class
+                    confidence = 1.0 - confidence  #Invert confidence for unknown class
 
                 print(f"\n[⚠️] Final prediction is {chosen_label} with uncertain confidence: {confidence:.1%}. Consider more consistent data for the model to learn from.")
             else:
@@ -17380,15 +17408,17 @@ class PipelinePredictionManager:
                             self.error_counts[result.get('predicted_idx')] += 1.0
 
                 if result['predicted'] == result['expected']:
-                    if result['sec_index'] is None:
+                    if 'sec_index' in result and result['sec_index'] is None:
                         result['sec_index'] = None
 
-                    self.pipeline.accurate_cache_lookup.add_verified(
-                        X_samples, input_ids, 
-                        result['predicted'], result['confidence'], result['predicted_idx'],
-                        source='automatic_verified')      
+                    if 'predicted_idx' in result and 'confidence' in result and 'predicted' in result:
+                        self.pipeline.accurate_cache_lookup.add_verified(
+                            X_samples, input_ids, 
+                            result['predicted'], result['confidence'], result['predicted_idx'],
+                            source='automatic_verified')      
 
-                    correct += 1
+                        correct += 1
+                        
                 else:
                     error += 1
                     if isinstance(self.error_counts[result.get('predicted_idx')], (int, float)):
@@ -17716,7 +17746,7 @@ class ConsecutivePeerAgent:
         
         best_result = local_result
         
-        # Step 2: If low confidence, ask peers
+        # Step 2: If low confidence, asking peers
         if local_result['confidence'] < confidence_threshold and peer_addresses or peer_addresses:
             if local_result['confidence'] < confidence_threshold:
                 print(f"[ConsecutivePeerAgent] Low confidence, asking {len(peer_addresses)} peers...")
@@ -18329,11 +18359,11 @@ class CohesiveAgentDeployment:
                 
                 # Send heartbeat to check connection
                 try:
-                    # self.pipeline.distribution._send_message(
-                        # sock, {'type': 'PING', 'timestamp': time.time()}
-                   # )
-                   sock.getpeername()
-                   print(f'[==] Peer name: {sock.getpeername()}')
+                    self.pipeline.distribution._send_message(
+                        sock, {'type': 'PING', 'timestamp': time.time()}
+                    )
+                    sock.getpeername()
+                    print(f'[==] Peer name: {sock.getpeername()}')
                 except:
                     logger.warning(f"[-] Peer {peer_host}:{peer_port} disconnected")
                     break