fix completions being not unique and duplicated

src/cmd/ls.rs

···
             } else {
                 // Non-glob path: check if it's a directory and list its contents
                 let normalized_path = path_str.trim_start_matches('/').trim_end_matches('/');
-                let target_path = base_path.join(normalized_path)
+                let target_path = base_path
+                    .join(normalized_path)
                     .map_err(to_shell_err(call.arguments_span()))?;
-                
+
                 let metadata = target_path.metadata().map_err(to_shell_err(span))?;
                 match metadata.file_type {
                     vfs::VfsFileType::Directory => {

src/completion/context.rs

···
 use crate::completion::helpers::*;
-use crate::completion::types::CompletionContext;
+use crate::completion::types::{CompletionContext, CompletionKind};
 use crate::console_log;
 use nu_parser::FlatShape;
 use nu_protocol::engine::{EngineState, StateWorkingSet};
···
         if let Some((cmd_name, _)) =
             find_command_and_arg_index(input, shapes, idx, local_span, global_offset)
         {
-            CompletionContext::Flag {
+            CompletionContext {
+                kind: CompletionKind::Flag {
+                    command_name: cmd_name,
+                },
                 prefix: trimmed_prefix.to_string(),
                 span,
-                command_name: cmd_name,
             }
         } else {
-            CompletionContext::Argument {
+            CompletionContext {
+                kind: CompletionKind::Argument,
                 prefix: prefix.to_string(),
                 span,
             }
···
         if let Some((cmd_name, arg_index)) =
             find_command_and_arg_index(input, shapes, idx, local_span, global_offset)
         {
-            CompletionContext::CommandArgument {
+            CompletionContext {
+                kind: CompletionKind::CommandArgument {
+                    command_name: cmd_name,
+                    arg_index,
+                },
                 prefix: trimmed_prefix.to_string(),
                 span,
-                command_name: cmd_name,
-                arg_index,
             }
         } else {
-            CompletionContext::Argument {
+            CompletionContext {
+                kind: CompletionKind::Argument,
                 prefix: prefix.to_string(),
                 span,
             }
···
                 console_log!(
                     "[completion] {shape_name} is empty, showing subcommands of {cmd_name:?}"
                 );
-                Some(CompletionContext::Command {
+                Some(CompletionContext {
+                    kind: CompletionKind::Command {
+                        parent_command: Some(cmd_name),
+                    },
                     prefix: String::new(),
                     span: adjusted_span,
-                    parent_command: Some(cmd_name),
                 })
             } else {
                 // Truly empty - show all commands
                 console_log!("[completion] {shape_name} is empty, setting Command context");
-                Some(CompletionContext::Command {
+                Some(CompletionContext {
+                    kind: CompletionKind::Command {
+                        parent_command: None,
+                    },
                     prefix: String::new(),
                     span: adjusted_span,
-                    parent_command: None,
                 })
             }
         } else if let Some(last_sep_pos) = last_sep_pos_in_prefix {
···
             console_log!(
                 "[completion] {shape_name} has separator at {last_sep_pos}, after_sep={after_sep:?}, setting Command context"
             );
-            Some(CompletionContext::Command {
+            Some(CompletionContext {
+                kind: CompletionKind::Command {
+                    parent_command: None,
+                },
                 prefix: after_sep.to_string(),
                 span: Span::new(span.start + last_sep_pos, span.end),
-                parent_command: None,
             })
         } else {
             console_log!(
···
                         console_log!(
                             "[completion] {shape_name}: Setting CellPath context with var {var_name:?}, prefix {cell_prefix:?}"
                         );
-                        Some(CompletionContext::CellPath {
+                        Some(CompletionContext {
+                            kind: CompletionKind::CellPath {
+                                var_id,
+                                path_so_far: path_so_far.iter().map(|s| s.to_string()).collect(),
+                            },
                             prefix: cell_prefix.to_string(),
                             span: Span::new(cell_span_start, adjusted_span.end),
-                            var_id,
-                            path_so_far: path_so_far.iter().map(|s| s.to_string()).collect(),
                         })
                     } else {
                         // Unknown variable, fall back to variable completion
···
                         console_log!(
                             "[completion] {shape_name}: Unknown var, setting Variable context with prefix {var_prefix:?}"
                         );
-                        Some(CompletionContext::Variable {
+                        Some(CompletionContext {
+                            kind: CompletionKind::Variable,
                             prefix: var_prefix,
                             span: adjusted_span,
                         })
···
                     console_log!(
                         "[completion] {shape_name}: Setting Variable context with prefix {var_prefix:?}"
                     );
-                    Some(CompletionContext::Variable {
+                    Some(CompletionContext {
+                        kind: CompletionKind::Variable,
                         prefix: var_prefix,
                         span: adjusted_span,
                     })
···
                     console_log!(
                         "[completion] {shape_name}: Found command {cmd_name:?} for flag completion"
                     );
-                    Some(CompletionContext::Flag {
+                    Some(CompletionContext {
+                        kind: CompletionKind::Flag {
+                            command_name: cmd_name,
+                        },
                         prefix: trimmed.to_string(),
                         span: adjusted_span,
-                        command_name: cmd_name,
                     })
                 } else {
-                    Some(CompletionContext::Argument {
+                    Some(CompletionContext {
+                        kind: CompletionKind::Argument,
                         prefix: trimmed_prefix.to_string(),
                         span: adjusted_span,
                     })
···
                     console_log!(
                         "[completion] {shape_name}: Found command {cmd_name:?} with arg_index {arg_index} for argument completion"
                     );
-                    Some(CompletionContext::CommandArgument {
+                    Some(CompletionContext {
+                        kind: CompletionKind::CommandArgument {
+                            command_name: cmd_name,
+                            arg_index,
+                        },
                         prefix: trimmed.to_string(),
                         span: adjusted_span,
-                        command_name: cmd_name,
-                        arg_index,
                     })
                 } else {
                     // No command found, treat as regular argument
                     console_log!(
                         "[completion] {shape_name}: No command found, using Argument context"
                     );
-                    Some(CompletionContext::Argument {
+                    Some(CompletionContext {
+                        kind: CompletionKind::Argument,
                         prefix: trimmed_prefix.to_string(),
                         span: adjusted_span,
                     })
···
             console_log!(
                 "[completion] Detected cell path from Variable+String shapes, var_id={var_id:?}, prefix={cell_prefix:?}, path={path_so_far:?}"
             );
-            Some(CompletionContext::CellPath {
+            Some(CompletionContext {
+                kind: CompletionKind::CellPath {
+                    var_id,
+                    path_so_far: path_so_far.iter().map(|s| s.to_string()).collect(),
+                },
                 prefix: cell_prefix.to_string(),
                 span: Span::new(cell_span_start, span.end),
-                var_id,
-                path_so_far: path_so_far.iter().map(|s| s.to_string()).collect(),
             })
         } else {
             // Gap between shapes, use helper to determine context
···
     global_offset: usize,
 ) -> Option<CompletionContext> {
     if idx == 0 {
-        return Some(CompletionContext::Argument {
+        return Some(CompletionContext {
+            kind: CompletionKind::Argument,
             prefix: prefix.to_string(),
             span,
         });
···
             console_log!(
                 "[completion] Detected cell path from adjacent Variable shape, var_id={var_id:?}, prefix={cell_prefix:?}"
             );
-            Some(CompletionContext::CellPath {
+            Some(CompletionContext {
+                kind: CompletionKind::CellPath {
+                    var_id,
+                    path_so_far: path_so_far.iter().map(|s| s.to_string()).collect(),
+                },
                 prefix: cell_prefix.to_string(),
                 span: Span::new(cell_span_start, span.end),
-                var_id,
-                path_so_far: path_so_far.iter().map(|s| s.to_string()).collect(),
             })
         } else {
             // Gap between shapes, fall through to default handling
-            Some(CompletionContext::Argument {
+            Some(CompletionContext {
+                kind: CompletionKind::Argument,
                 prefix: prefix.to_string(),
                 span,
             })
         }
     } else {
         // Previous shape is not a Variable, this is likely a file path starting with .
-        Some(CompletionContext::Argument {
+        Some(CompletionContext {
+            kind: CompletionKind::Argument,
             prefix: prefix.to_string(),
             span,
         })
···
             if trimmed_prefix == "{" {
                 // We're right after '{' - command context
                 if let Some((_, adjusted_span, _)) = handle_block_prefix(&prefix, span) {
-                    return Some(CompletionContext::Command {
+                    return Some(CompletionContext {
+                        kind: CompletionKind::Command {
+                            parent_command: None,
+                        },
                         prefix: String::new(),
                         span: adjusted_span,
-                        parent_command: None,
                     });
                 }
             } else {
···
                                 // Calculate span for the cell path member being completed
                                 let prefix_byte_len = cell_prefix.len();
                                 let cell_span_start = span.end.saturating_sub(prefix_byte_len);
-                                return Some(CompletionContext::CellPath {
+                                return Some(CompletionContext {
+                                    kind: CompletionKind::CellPath {
+                                        var_id,
+                                        path_so_far: path_so_far
+                                            .iter()
+                                            .map(|s| s.to_string())
+                                            .collect(),
+                                    },
                                     prefix: cell_prefix.to_string(),
                                     span: Span::new(cell_span_start, span.end),
-                                    var_id,
-                                    path_so_far: path_so_far
-                                        .iter()
-                                        .map(|s| s.to_string())
-                                        .collect(),
                                 });
                             } else {
                                 // Unknown variable, fall back to variable completion
                                 let var_prefix = trimmed_prefix[1..].to_string();
-                                return Some(CompletionContext::Variable {
+                                return Some(CompletionContext {
+                                    kind: CompletionKind::Variable,
                                     prefix: var_prefix,
                                     span,
                                 });
···
                             } else {
                                 String::new()
                             };
-                            return Some(CompletionContext::Variable {
+                            return Some(CompletionContext {
+                                kind: CompletionKind::Variable,
                                 prefix: var_prefix,
                                 span,
                             });
···
                     _ if is_command_shape(input, shape, local_span) => {
                         let (full_prefix, full_span) =
                             build_command_prefix(input, shapes, idx, span, &prefix, global_offset);
-                        return Some(CompletionContext::Command {
+                        return Some(CompletionContext {
+                            kind: CompletionKind::Command {
+                                parent_command: None,
+                            },
                             prefix: full_prefix,
                             span: full_span,
-                            parent_command: None,
                         });
                     }
                     FlatShape::Block | FlatShape::Closure => {
···
                             {
                                 let prefix_byte_len = cell_prefix.len();
                                 let cell_span_start = span.end.saturating_sub(prefix_byte_len);
-                                return Some(CompletionContext::CellPath {
+                                return Some(CompletionContext {
+                                    kind: CompletionKind::CellPath {
+                                        var_id: *var_id,
+                                        path_so_far: path_so_far
+                                            .iter()
+                                            .map(|s| s.to_string())
+                                            .collect(),
+                                    },
                                     prefix: cell_prefix.to_string(),
                                     span: Span::new(cell_span_start, span.end),
-                                    var_id: *var_id,
-                                    path_so_far: path_so_far
-                                        .iter()
-                                        .map(|s| s.to_string())
-                                        .collect(),
                                 });
                             } else {
                                 // Simple variable completion
                                 let var_prefix = trimmed_prefix[1..].to_string();
-                                return Some(CompletionContext::Variable {
+                                return Some(CompletionContext {
+                                    kind: CompletionKind::Variable,
                                     prefix: var_prefix,
                                     span,
                                 });
                             }
                         } else {
                             // Fallback to argument context if no $ found
-                            return Some(CompletionContext::Argument {
+                            return Some(CompletionContext {
+                                kind: CompletionKind::Argument,
                                 prefix: prefix.to_string(),
                                 span,
                             });
···
                                 if let Some(var_id) = var_id {
                                     let prefix_byte_len = cell_prefix.len();
                                     let cell_span_start = span.end.saturating_sub(prefix_byte_len);
-                                    return Some(CompletionContext::CellPath {
+                                    return Some(CompletionContext {
+                                        kind: CompletionKind::CellPath {
+                                            var_id,
+                                            path_so_far: path_so_far
+                                                .iter()
+                                                .map(|s| s.to_string())
+                                                .collect(),
+                                        },
                                         prefix: cell_prefix.to_string(),
                                         span: Span::new(cell_span_start, span.end),
-                                        var_id,
-                                        path_so_far: path_so_far
-                                            .iter()
-                                            .map(|s| s.to_string())
-                                            .collect(),
                                     });
                                 } else {
                                     let var_prefix = trimmed_prefix[1..].to_string();
-                                    return Some(CompletionContext::Variable {
+                                    return Some(CompletionContext {
+                                        kind: CompletionKind::Variable,
                                         prefix: var_prefix,
                                         span,
                                     });
···
                                 } else {
                                     String::new()
                                 };
-                                return Some(CompletionContext::Variable {
+                                return Some(CompletionContext {
+                                    kind: CompletionKind::Variable,
                                     prefix: var_prefix,
                                     span,
                                 });
···
                                     "[completion] Right after command {cmd_name:?}, setting CommandArgument context with arg_index: {arg_count}"
                                 );
 
-                                context.push(CompletionContext::CommandArgument {
+                                context.push(CompletionContext {
+                                    kind: CompletionKind::CommandArgument {
+                                        command_name: cmd_name.clone(),
+                                        arg_index: arg_count,
+                                    },
                                     prefix: String::new(),
                                     span: Span::new(byte_pos, byte_pos),
-                                    command_name: cmd_name.clone(),
-                                    arg_index: arg_count,
                                 });
                             }
                         }
···
                             console_log!(
                                 "[completion] Command {cmd_name:?} has no positional args, showing subcommands"
                             );
-                            context.push(CompletionContext::Command {
+                            context.push(CompletionContext {
+                                kind: CompletionKind::Command {
+                                    parent_command: Some(cmd_first_word),
+                                },
                                 prefix: String::new(),
                                 span: Span::new(byte_pos, byte_pos),
-                                parent_command: Some(cmd_first_word),
                             });
                         }
                         // reverse to put subcommands in the beginning
···
                     } else {
                         // Not right after command, complete the command itself
                         console_log!("[completion] Set Command context with prefix: {cmd:?}");
-                        return vec![CompletionContext::Command {
+                        return vec![CompletionContext {
+                            kind: CompletionKind::Command {
+                                parent_command: None,
+                            },
                             prefix: cmd.to_string(),
                             span: local_span,
-                            parent_command: None,
                         }];
                     }
                 }
···
     console_log!("[completion] last_word_start={last_word_start}, last_word={last_word:?}");
 
     if is_cmd_context {
-        vec![CompletionContext::Command {
+        vec![CompletionContext {
+            kind: CompletionKind::Command {
+                parent_command: None,
+            },
             prefix: last_word.to_string(),
             span: Span::new(last_word_start, byte_pos),
-            parent_command: None,
         }]
     } else {
         // Check if this is a variable or cell path (starts with $)
···
                 if let Some(var_id) = var_id {
                     let prefix_byte_len = cell_prefix.len();
                     let cell_span_start = byte_pos.saturating_sub(prefix_byte_len);
-                    vec![CompletionContext::CellPath {
+                    vec![CompletionContext {
+                        kind: CompletionKind::CellPath {
+                            var_id,
+                            path_so_far: path_so_far.iter().map(|s| s.to_string()).collect(),
+                        },
                         prefix: cell_prefix.to_string(),
                         span: Span::new(cell_span_start, byte_pos),
-                        var_id,
-                        path_so_far: path_so_far.iter().map(|s| s.to_string()).collect(),
                     }]
                 } else {
                     let var_prefix = trimmed_word[1..].to_string();
-                    vec![CompletionContext::Variable {
+                    vec![CompletionContext {
+                        kind: CompletionKind::Variable,
                         prefix: var_prefix,
                         span: Span::new(last_word_start, byte_pos),
                     }]
···
             } else {
                 // Simple variable completion
                 let var_prefix = trimmed_word[1..].to_string();
-                vec![CompletionContext::Variable {
+                vec![CompletionContext {
+                    kind: CompletionKind::Variable,
                     prefix: var_prefix,
                     span: Span::new(last_word_start, byte_pos),
                 }]
···
                 }
             }
             if let Some(cmd_name) = found_cmd {
-                vec![CompletionContext::Flag {
+                vec![CompletionContext {
+                    kind: CompletionKind::Flag {
+                        command_name: cmd_name,
+                    },
                     prefix: trimmed_word.to_string(),
                     span: Span::new(last_word_start, byte_pos),
-                    command_name: cmd_name,
                 }]
             } else {
-                vec![CompletionContext::Argument {
+                vec![CompletionContext {
+                    kind: CompletionKind::Argument,
                     prefix: last_word.to_string(),
                     span: Span::new(last_word_start, byte_pos),
                 }]
···
                 }
             }
             if let Some(cmd_name) = found_cmd {
-                vec![CompletionContext::CommandArgument {
+                vec![CompletionContext {
+                    kind: CompletionKind::CommandArgument {
+                        command_name: cmd_name,
+                        arg_index: arg_count,
+                    },
                     prefix: trimmed_word.to_string(),
                     span: Span::new(last_word_start, byte_pos),
-                    command_name: cmd_name,
-                    arg_index: arg_count,
                 }]
             } else {
-                vec![CompletionContext::Argument {
+                vec![CompletionContext {
+                    kind: CompletionKind::Argument,
                     prefix: last_word.to_string(),
                     span: Span::new(last_word_start, byte_pos),
                 }]

src/completion/mod.rs

···
         global_offset,
     );
 
+    // Convert Vec to HashSet
+    use std::collections::HashSet;
+    let context_set: HashSet<CompletionContext> = context.into_iter().collect();
+
     // Generate suggestions based on context
     let suggestions = generate_suggestions(
         &input,
-        context,
+        context_set,
         &working_set,
         &engine_guard,
         &stack_guard,

src/completion/suggestions.rs

···
 use crate::completion::context::get_command_signature;
 use crate::completion::helpers::to_char_span;
-use crate::completion::types::{CompletionContext, Suggestion};
+use crate::completion::types::{CompletionContext, CompletionKind, Suggestion};
 use crate::completion::variables::*;
 use crate::console_log;
 use nu_protocol::Span;
 use nu_protocol::engine::{EngineState, Stack, StateWorkingSet};
+use std::collections::HashSet;
 
 pub fn generate_command_suggestions(
     input: &str,
···
     );
 
     let mut suggestions = Vec::new();
-    
+
     // If we're at argument index 0, check if the command has subcommands and add them
     if arg_index == 0 {
         let parent_prefix = format!("{} ", command_name);
···
         } else {
             format!("{}{}", parent_prefix, prefix)
         };
-        
+
         let subcommands = working_set
             .find_commands_by_predicate(|value| value.starts_with(search_prefix.as_bytes()), true);
-        
+
         if !subcommands.is_empty() {
             // Command has subcommands - add them to suggestions
             console_log!(
···
                 if let Some(subcommand_name) = name_str.strip_prefix(&parent_prefix) {
                     suggestions.push(Suggestion {
                         rendered: {
-                            let name_colored = ansi_term::Color::Green.bold().paint(subcommand_name);
+                            let name_colored =
+                                ansi_term::Color::Green.bold().paint(subcommand_name);
                             let desc_str = desc.as_deref().unwrap_or("<no description>");
                             format!("{name_colored} {desc_str}")
                         },
···
             }
         }
     }
-    
+
     if let Some(signature) = get_command_signature(engine_guard, &command_name) {
         // First, check if we're completing an argument for a flag
         // Look backwards from the current position to find the previous flag
···
 
 pub fn generate_suggestions(
     input: &str,
-    contexts: Vec<CompletionContext>,
+    contexts: HashSet<CompletionContext>,
     working_set: &StateWorkingSet,
     engine_guard: &EngineState,
     stack_guard: &Stack,
···
 ) -> Vec<Suggestion> {
     console_log!("contexts: {contexts:?}");
 
+    let mut context_vec: Vec<_> = contexts.into_iter().collect();
+    context_vec.sort_by_key(|ctx| match &ctx.kind {
+        CompletionKind::Command { .. } => 0,
+        CompletionKind::Flag { .. } => 1,
+        CompletionKind::Variable => 2,
+        CompletionKind::CellPath { .. } => 3,
+        CompletionKind::CommandArgument { .. } => 4,
+        CompletionKind::Argument => 5,
+    });
+
     let mut suggestions = Vec::new();
-    for context in contexts {
-        let mut sug = match context {
-            CompletionContext::Command {
-                prefix,
-                span,
-                parent_command,
-            } => generate_command_suggestions(input, working_set, prefix, span, parent_command),
-            CompletionContext::Argument { prefix, span } => {
-                generate_argument_suggestions(input, prefix, span, root)
+    for context in context_vec.iter() {
+        let mut sug = match &context.kind {
+            CompletionKind::Command { parent_command } => generate_command_suggestions(
+                input,
+                working_set,
+                context.prefix.clone(),
+                context.span,
+                parent_command.clone(),
+            ),
+            CompletionKind::Argument => {
+                generate_argument_suggestions(input, context.prefix.clone(), context.span, root)
             }
-            CompletionContext::Flag {
-                prefix,
-                span,
-                command_name,
-            } => generate_flag_suggestions(input, engine_guard, prefix, span, command_name),
-            CompletionContext::CommandArgument {
-                prefix,
-                span,
+            CompletionKind::Flag { command_name } => generate_flag_suggestions(
+                input,
+                engine_guard,
+                context.prefix.clone(),
+                context.span,
+                command_name.clone(),
+            ),
+            CompletionKind::CommandArgument {
                 command_name,
                 arg_index,
             } => generate_command_argument_suggestions(
                 input,
                 engine_guard,
                 working_set,
-                prefix,
-                span,
-                command_name,
-                arg_index,
+                context.prefix.clone(),
+                context.span,
+                command_name.clone(),
+                *arg_index,
                 root,
             ),
-            CompletionContext::Variable { prefix, span } => {
-                generate_variable_suggestions(input, working_set, prefix, span, byte_pos)
-            }
-            CompletionContext::CellPath {
-                prefix,
-                span,
+            CompletionKind::Variable => generate_variable_suggestions(
+                input,
+                working_set,
+                context.prefix.clone(),
+                context.span,
+                byte_pos,
+            ),
+            CompletionKind::CellPath {
                 var_id,
                 path_so_far,
             } => generate_cell_path_suggestions(
···
                 working_set,
                 engine_guard,
                 stack_guard,
-                prefix,
-                span,
-                var_id,
-                path_so_far,
+                context.prefix.clone(),
+                context.span,
+                *var_id,
+                path_so_far.clone(),
             ),
         };
         suggestions.append(&mut sug);

src/completion/types.rs

···
     }
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub enum CompletionContext {
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum CompletionKind {
     Command {
-        prefix: String,
-        span: Span,
         parent_command: Option<String>, // If Some, only show subcommands of this command
     },
-    Argument {
-        prefix: String,
-        span: Span,
-    },
+    Argument,
     Flag {
-        prefix: String,
-        span: Span,
         command_name: String,
     },
     CommandArgument {
-        prefix: String,
-        span: Span,
         command_name: String,
         arg_index: usize,
     },
-    Variable {
-        prefix: String, // without the $ prefix
-        span: Span,
-    },
+    Variable, // prefix is without the $ prefix
     CellPath {
-        prefix: String,             // the partial field name being typed (after the last dot)
-        span: Span,                 // replacement span
         var_id: nu_protocol::VarId, // variable ID for evaluation
         path_so_far: Vec<String>,   // path members accessed before current one
     },
 }
+
+#[derive(Debug)]
+pub struct CompletionContext {
+    pub kind: CompletionKind,
+    pub prefix: String, // the partial text being completed
+    pub span: Span,
+}
+
+impl PartialEq for CompletionContext {
+    fn eq(&self, other: &Self) -> bool {
+        self.kind == other.kind && self.prefix == other.prefix
+    }
+}
+
+impl Eq for CompletionContext {}
+
+impl PartialOrd for CompletionContext {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        match self.kind.partial_cmp(&other.kind) {
+            Some(std::cmp::Ordering::Equal) => self.prefix.partial_cmp(&other.prefix),
+            other => other,
+        }
+    }
+}
+
+impl Ord for CompletionContext {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        match self.kind.cmp(&other.kind) {
+            std::cmp::Ordering::Equal => self.prefix.cmp(&other.prefix),
+            other => other,
+        }
+    }
+}
+
+impl std::hash::Hash for CompletionContext {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.kind.hash(state);
+        self.prefix.hash(state);
+    }
+}