diff --git a/qodana.yaml b/qodana.yaml
index 5942f979..5295f6d0 100644
--- a/qodana.yaml
+++ b/qodana.yaml
@@ -10,4 +10,4 @@ exclude:
       - src/bench2.4
       - src/benchCurrent
       - src/profiler
-      - src/samples/ParserExample
+      - src/samples
diff --git a/src/samples/postProcessedLexerParser/expressionModel/FunctionCall.cs b/src/samples/postProcessedLexerParser/expressionModel/FunctionCall.cs
index efa63735..76c72354 100644
--- a/src/samples/postProcessedLexerParser/expressionModel/FunctionCall.cs
+++ b/src/samples/postProcessedLexerParser/expressionModel/FunctionCall.cs
@@ -9,9 +9,10 @@ public class FunctionCall : Expression
 
         public static double Sin(IEnumerable<double?> parameters)
         {
-            if (parameters.Count() == 1 && parameters.First().HasValue)
+            var enumerable = parameters as double?[] ?? parameters.ToArray();
+            if (enumerable.Any() && enumerable.First().HasValue)
             {
-                return Math.Sin(parameters.First().Value);
+                return Math.Sin(enumerable.First().Value);
             }
 
             return 0.0;
@@ -19,27 +20,30 @@ public static double Sin(IEnumerable<double?> parameters)
         
         public static double Cos(IEnumerable<double?> parameters)
         {
-            if (parameters.Count() == 1 && parameters.First().HasValue)
+            var enumerable = parameters as double?[] ?? parameters.ToArray();
+            if (enumerable.Count() == 1 && enumerable.First().HasValue)
             {
-                return Math.Cos(parameters.First().Value);
+                return Math.Cos(enumerable.First().Value);
             }
             return 0.0;
         }
         
         public static double Tan(IEnumerable<double?> parameters)
         {
-            if (parameters.Count() == 1 && parameters.First().HasValue)
+            var enumerable = parameters as double?[] ?? parameters.ToArray();
+            if (enumerable.Count() == 1 && enumerable.First().HasValue)
             {
-                return Math.Tan(parameters.First().Value);
+                return Math.Tan(enumerable.First().Value);
             }
             return 0.0;
         }
         
         public static double Sqrt(IEnumerable<double?> parameters)
         {
-            if (parameters.Count() == 1 && parameters.First().HasValue)
+            var enumerable = parameters as double?[] ?? parameters.ToArray();
+            if (enumerable.Count() == 1 && enumerable.First().HasValue)
             {
-                return Math.Sqrt(parameters.First().Value);
+                return Math.Sqrt(enumerable.First().Value);
             }
             return 0.0;
         }
diff --git a/src/sly/lexer/GenericLexer.cs b/src/sly/lexer/GenericLexer.cs
index ffbd3e3a..585e38a9 100644
--- a/src/sly/lexer/GenericLexer.cs
+++ b/src/sly/lexer/GenericLexer.cs
@@ -430,11 +430,10 @@ public void AddLexeme(GenericToken generic, IN token)
                 {
                     case GenericToken.Identifier:
                     {
-                        if (derivedTokens.ContainsKey(GenericToken.Identifier))
+                        if (derivedTokens.TryGetValue(GenericToken.Identifier, out var possibleTokens))
                         {
-                            var possibleTokens = derivedTokens[GenericToken.Identifier];
-                            if (possibleTokens.ContainsKey(match.Result.Value))
-                                match.Properties[DerivedToken] = possibleTokens[match.Result.Value].tokenId;
+                            if (possibleTokens.TryGetValue(match.Result.Value, out var possibleToken))
+                                match.Properties[DerivedToken] = possibleToken.tokenId;
                             else
                                 match.Properties[DerivedToken] = identifierDerivedToken;
                         }
@@ -1114,7 +1113,7 @@ public Token<IN> Transcode(FSMMatch<GenericToken> match)
             tok.Position = inTok.Position;
             tok.Discarded = inTok.Discarded;
             tok.StringDelimiter = match.StringDelimiterChar;
-            tok.TokenID = match.Properties.ContainsKey(DerivedToken) ? (IN)match.Properties[DerivedToken] : default(IN);
+            tok.TokenID = match.Properties.TryGetValue(DerivedToken, out var property) ? (IN)property : default;
             tok.IsLineEnding = match.IsLineEnding;
             tok.IsEOS = match.IsEOS;
             tok.IsIndent = match.IsIndent;
diff --git a/src/sly/lexer/LexerBuilder.cs b/src/sly/lexer/LexerBuilder.cs
index 306a0a5c..744d784b 100644
--- a/src/sly/lexer/LexerBuilder.cs
+++ b/src/sly/lexer/LexerBuilder.cs
@@ -636,7 +636,6 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                                 result.Errors.AddRange(resultx.Errors);
                                 lexer.AddKeyWord(default(IN), explicitToken, false, false,
                                     ModeAttribute.DefaultLexerMode, resultx);
-                                ;
                             }
                             else
                             {
diff --git a/src/sly/lexer/fsm/FSMLexer.cs b/src/sly/lexer/fsm/FSMLexer.cs
index 7b16b74a..7d8419e4 100644
--- a/src/sly/lexer/fsm/FSMLexer.cs
+++ b/src/sly/lexer/fsm/FSMLexer.cs
@@ -111,10 +111,9 @@ public FSMTransition GetTransition(int nodeId, char token)
         {
             FSMTransition transition = null;
             if (HasState(nodeId))
-                if (Transitions.ContainsKey(nodeId))
+                if (Transitions.TryGetValue(nodeId, out var leavingTransitions))
                 {
-                    var leavingTransitions = Transitions[nodeId];
-                    transition = leavingTransitions.FirstOrDefault<FSMTransition>(t => t.Match(token));
+                    transition = leavingTransitions.FirstOrDefault(t => t.Match(token));
                 }
 
             return transition;
@@ -124,7 +123,7 @@ public FSMTransition GetTransition(int nodeId, char token)
         public void AddTransition(FSMTransition transition)
         {
             var transitions = new List<FSMTransition>();
-            if (Transitions.ContainsKey(transition.FromNode)) transitions = Transitions[transition.FromNode];
+            if (Transitions.TryGetValue(transition.FromNode, out var transition1)) transitions = transition1;
             transitions.Add(transition);
             Transitions[transition.FromNode] = transitions;
         }
@@ -182,7 +181,6 @@ public List<char> GetIndentations(ReadOnlyMemory<char> source, int index)
             if (index >= source.Length)
             {
                 return new List<char>();
-                ;
             }
 
             char current = source.At<char>(index + i);
@@ -412,7 +410,6 @@ private FSMMatch<N> ConsumeIndents(ReadOnlyMemory<char> source, LexerPosition le
                         return indent;
                     }
 
-                    ;
                     return null;
                 }
             }
diff --git a/src/sly/lexer/fsm/FSMLexerBuilder.cs b/src/sly/lexer/fsm/FSMLexerBuilder.cs
index f1642693..e760bdc4 100644
--- a/src/sly/lexer/fsm/FSMLexerBuilder.cs
+++ b/src/sly/lexer/fsm/FSMLexerBuilder.cs
@@ -40,8 +40,8 @@ public FSMLexerBuilder<N> GoTo(int state)
 
         public FSMLexerBuilder<N> GoTo(string mark)
         {
-            if (Marks.ContainsKey(mark))
-                GoTo(Marks[mark]);
+            if (Marks.TryGetValue(mark, out var mark1))
+                GoTo(mark1);
             else
                 throw new ArgumentException($"mark {mark} does not exist in current builder");
             return this;
@@ -63,7 +63,7 @@ public FSMNode<N> GetNode(int nodeId)
         public FSMNode<N> GetNode(string mark)
         {
             FSMNode<N> node = null;
-            if (Marks.ContainsKey(mark)) node = GetNode(Marks[mark]);
+            if (Marks.TryGetValue(mark, out var mark1)) node = GetNode(mark1);
             return node;
         }
         
diff --git a/src/sly/parser/generator/ExpressionRulesGenerator.cs b/src/sly/parser/generator/ExpressionRulesGenerator.cs
index 0a78b98d..2508d5f7 100644
--- a/src/sly/parser/generator/ExpressionRulesGenerator.cs
+++ b/src/sly/parser/generator/ExpressionRulesGenerator.cs
@@ -79,8 +79,8 @@ public BuildResult<ParserConfiguration<IN, OUT>> BuildExpressionRules(
                     }
 
                     var operations = new List<OperationMetaData<IN>>();
-                    if (operationsByPrecedence.ContainsKey(operation.Precedence))
-                        operations = operationsByPrecedence[operation.Precedence];
+                    if (operationsByPrecedence.TryGetValue(operation.Precedence, out var value))
+                        operations = value;
                     operations.Add(operation);
                     operationsByPrecedence[operation.Precedence] = operations;
                 }
diff --git a/src/sly/parser/generator/LeftRecursionChecker.cs b/src/sly/parser/generator/LeftRecursionChecker.cs
index 83e63328..cf37cbc4 100644
--- a/src/sly/parser/generator/LeftRecursionChecker.cs
+++ b/src/sly/parser/generator/LeftRecursionChecker.cs
@@ -109,9 +109,8 @@ public static (bool recursionFound,List<List<string>> recursion) CheckLeftRecurs
             
             foreach (var leftClause in leftClauses)
             {
-                if (configuration.NonTerminals.ContainsKey(leftClause))
+                if (configuration.NonTerminals.TryGetValue(leftClause, out var newNonTerminal))
                 {
-                    var newNonTerminal = configuration.NonTerminals[leftClause];
                     if (newNonTerminal != null)
                     {
                         var nPath = BuildPath(currentPath, leftClause);
@@ -124,10 +123,6 @@ public static (bool recursionFound,List<List<string>> recursion) CheckLeftRecurs
 
                     }
                 }
-                else
-                {
-                    ;
-                }
             }
 
             return (foundRecursion, recursions);
diff --git a/src/sly/parser/generator/ParserBuilder.cs b/src/sly/parser/generator/ParserBuilder.cs
index e15fd8f8..cecaed70 100644
--- a/src/sly/parser/generator/ParserBuilder.cs
+++ b/src/sly/parser/generator/ParserBuilder.cs
@@ -473,10 +473,6 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
             if (!rule.IsExpressionRule)
             {
                 var visitor = rule.GetVisitor();
-                if (visitor == null)
-                {
-                    ;
-                }
 
                 var returnInfo = visitor.ReturnParameter;
                 var expectedReturn = typeof(OUT);
diff --git a/src/sly/parser/parser/Group.cs b/src/sly/parser/parser/Group.cs
index b936b43b..ce630414 100644
--- a/src/sly/parser/parser/Group.cs
+++ b/src/sly/parser/parser/Group.cs
@@ -7,9 +7,9 @@ namespace sly.parser.parser
 {
     public class Group<IN, OUT> where IN : struct
     {
-        public List<GroupItem<IN, OUT>> Items;
+        public readonly List<GroupItem<IN, OUT>> Items;
 
-        public Dictionary<string, GroupItem<IN, OUT>> ItemsByName;
+        private Dictionary<string, GroupItem<IN, OUT>> ItemsByName;
 
         public Group()
         {
@@ -33,12 +33,12 @@ public Token<IN> Token(int i)
 
         public OUT Value(string name)
         {
-            return ItemsByName.ContainsKey(name) ? ItemsByName[name].Value : default(OUT);
+            return ItemsByName.TryGetValue(name, out var value) ? value.Value : default(OUT);
         }
 
         public Token<IN> Token(string name)
         {
-            return ItemsByName.ContainsKey(name) ? ItemsByName[name].Token : null;
+            return ItemsByName.TryGetValue(name, out var value) ? value.Token : null;
         }
 
         public void Add(string name, Token<IN> token)
diff --git a/src/sly/parser/parser/llparser/EBNFRecursiveDescentSyntaxParserStarter.cs b/src/sly/parser/parser/llparser/EBNFRecursiveDescentSyntaxParserStarter.cs
index 071b2bdb..120e9306 100644
--- a/src/sly/parser/parser/llparser/EBNFRecursiveDescentSyntaxParserStarter.cs
+++ b/src/sly/parser/parser/llparser/EBNFRecursiveDescentSyntaxParserStarter.cs
@@ -169,9 +169,8 @@ private void InitStartingTokensWithNonTerminal(Rule<IN> rule, NonTerminalClause<
             Dictionary<string, NonTerminal<IN>> nonTerminals)
         {
             InitStartingTokensForNonTerminal(nonTerminals, nonterm.NonTerminalName);
-            if (nonTerminals.ContainsKey(nonterm.NonTerminalName))
+            if (nonTerminals.TryGetValue(nonterm.NonTerminalName, out var firstNonTerminal))
             {
-                var firstNonTerminal = nonTerminals[nonterm.NonTerminalName];
                 firstNonTerminal.Rules.ForEach(r => { rule.PossibleLeadingTokens.AddRange(r.PossibleLeadingTokens); });
                 rule.PossibleLeadingTokens = rule.PossibleLeadingTokens.Distinct().ToList();
             }
diff --git a/src/sly/parser/parser/llparser/RecursiveDescentSyntaxParserStarter.cs b/src/sly/parser/parser/llparser/RecursiveDescentSyntaxParserStarter.cs
index 7a8a1dc7..55dd8931 100644
--- a/src/sly/parser/parser/llparser/RecursiveDescentSyntaxParserStarter.cs
+++ b/src/sly/parser/parser/llparser/RecursiveDescentSyntaxParserStarter.cs
@@ -120,9 +120,8 @@ protected virtual void InitializeStartingTokens(ParserConfiguration<IN, OUT> con
         protected virtual void InitStartingTokensForNonTerminal(Dictionary<string, NonTerminal<IN>> nonTerminals,
             string name)
         {
-            if (nonTerminals.ContainsKey(name))
+            if (nonTerminals.TryGetValue(name, out var nt))
             {
-                var nt = nonTerminals[name];
                 nt.Rules.ForEach(r => InitStartingTokensForRule(nonTerminals, r));
             }
         }
@@ -130,38 +129,33 @@ protected virtual void InitStartingTokensForNonTerminal(Dictionary<string, NonTe
         protected void InitStartingTokensForRule(Dictionary<string, NonTerminal<IN>> nonTerminals,
             Rule<IN> rule)
         {
-            if (rule.PossibleLeadingTokens == null || rule.PossibleLeadingTokens.Count == 0)
+            if (rule.PossibleLeadingTokens != null && rule.PossibleLeadingTokens.Count != 0) return;
+            rule.PossibleLeadingTokens = new List<LeadingToken<IN>>();
+            if (rule.Clauses.Count <= 0) return;
+            var first = rule.Clauses[0];
+            switch (first)
             {
-                rule.PossibleLeadingTokens = new List<LeadingToken<IN>>();
-                if (rule.Clauses.Count > 0)
+                case TerminalClause<IN> term:
+                    rule.PossibleLeadingTokens.Add(term.ExpectedToken);
+                    rule.PossibleLeadingTokens = rule.PossibleLeadingTokens.Distinct().ToList();
+                    break;
+                case NonTerminalClause<IN> nonTerminalClause:
                 {
-                    var first = rule.Clauses[0];
-                    switch (first)
+                    InitStartingTokensForNonTerminal(nonTerminals, nonTerminalClause.NonTerminalName);
+                    if (nonTerminals.TryGetValue(nonTerminalClause.NonTerminalName, out var firstNonTerminal))
                     {
-                        case TerminalClause<IN> term:
-                            rule.PossibleLeadingTokens.Add(term.ExpectedToken);
-                            rule.PossibleLeadingTokens = rule.PossibleLeadingTokens.Distinct().ToList();
-                            break;
-                        case NonTerminalClause<IN> nonterm:
+                        firstNonTerminal.Rules.ForEach(r =>
                         {
-                            InitStartingTokensForNonTerminal(nonTerminals, nonterm.NonTerminalName);
-                            if (nonTerminals.ContainsKey(nonterm.NonTerminalName))
-                            {
-                                var firstNonTerminal = nonTerminals[nonterm.NonTerminalName];
-                                firstNonTerminal.Rules.ForEach(r =>
-                                {
-                                    rule.PossibleLeadingTokens.AddRange(r.PossibleLeadingTokens);
-                                });
-                                rule.PossibleLeadingTokens = rule.PossibleLeadingTokens.ToList();
-                            }
-
-                            break;
-                        }
-                        default:
-                            InitStartingTokensForRuleExtensions(first,rule,nonTerminals);
-                            break;
+                            rule.PossibleLeadingTokens.AddRange(r.PossibleLeadingTokens);
+                        });
+                        rule.PossibleLeadingTokens = rule.PossibleLeadingTokens.ToList();
                     }
+
+                    break;
                 }
+                default:
+                    InitStartingTokensForRuleExtensions(first,rule,nonTerminals);
+                    break;
             }
         }
 
diff --git a/src/sly/parser/syntax/grammar/Rule.cs b/src/sly/parser/syntax/grammar/Rule.cs
index 875c8257..fb28c132 100644
--- a/src/sly/parser/syntax/grammar/Rule.cs
+++ b/src/sly/parser/syntax/grammar/Rule.cs
@@ -93,8 +93,8 @@ public OperationMetaData<IN> GetOperation(IN token = default)
         {
             if (IsExpressionRule)
             {
-                var operation = VisitorMethodsForOperation.ContainsKey(token)
-                    ? VisitorMethodsForOperation[token]
+                var operation = VisitorMethodsForOperation.TryGetValue(token, out var value)
+                    ? value
                     : null;
                 return operation;
             }
@@ -117,8 +117,8 @@ public MethodInfo GetVisitor(IN token = default)
             MethodInfo visitor = null;
             if (IsExpressionRule)
             {
-                var operation = VisitorMethodsForOperation.ContainsKey(token)
-                    ? VisitorMethodsForOperation[token]
+                var operation = VisitorMethodsForOperation.TryGetValue(token, out var value)
+                    ? value
                     : null;
                 visitor = operation?.VisitorMethod;
             }