From 81e0f94dd4e15e4bb888f35bd3e46e923a29fce2 Mon Sep 17 00:00:00 2001
From: rusefillc <sdfsdfqsf2334234234>
Date: Sat, 18 Dec 2021 11:57:25 -0500
Subject: [PATCH] live data for wastegate and launch control #3588

PROGRESS!
---
 .../ui/resources/c_sources/ac_control.cpp     |  11 +-
 .../main/java/com/rusefi/CodeWalkthrough.java | 166 ++++
 .../rusefi/livedata/LiveDataParserPanel.java  |  77 +-
 .../livedata/LiveDataParserSandbox.java       |   7 +-
 .../ui/livedata/LiveDataParserTest.java       |  22 +-
 .../ui/livedata/PrintCPP14ParserListener.java | 781 +++++++++---------
 6 files changed, 585 insertions(+), 479 deletions(-)
 create mode 100644 java_console/ui/src/main/java/com/rusefi/CodeWalkthrough.java

diff --git a/java_console/ui/resources/c_sources/ac_control.cpp b/java_console/ui/resources/c_sources/ac_control.cpp
index f4384f154d..cd0855e28d 100644
--- a/java_console/ui/resources/c_sources/ac_control.cpp
+++ b/java_console/ui/resources/c_sources/ac_control.cpp
@@ -14,16 +14,19 @@ bool AcController::getAcState() {
 
 	engineTooSlow = rpm < 500;
 
-	if (engineTooSlow) {
-		return false;
-	}
-
 	auto maxRpm = engineConfiguration->maxAcRpm;
 	engineTooFast = maxRpm != 0 && maxRpmDeadband.gt(rpm, maxRpm);
 	if (engineTooFast) {
+	    invokeMethodRed();
 		return false;
 	}
 
+	if (engineTooSlow) {
+	    invokeMethod();
+		return false;
+	}
+
+
 	auto clt = Sensor::get(SensorType::Clt);
 
 	noClt = !clt;
diff --git a/java_console/ui/src/main/java/com/rusefi/CodeWalkthrough.java b/java_console/ui/src/main/java/com/rusefi/CodeWalkthrough.java
new file mode 100644
index 0000000000..e2cd115aa6
--- /dev/null
+++ b/java_console/ui/src/main/java/com/rusefi/CodeWalkthrough.java
@@ -0,0 +1,166 @@
+package com.rusefi;
+
+import com.devexperts.logging.Logging;
+import com.rusefi.livedata.ParseResult;
+import com.rusefi.livedata.generated.CPP14Parser;
+import com.rusefi.livedata.generated.CPP14ParserBaseListener;
+import com.rusefi.ui.livedata.Range;
+import com.rusefi.ui.livedata.SourceCodePainter;
+import com.rusefi.ui.livedata.VariableValueSource;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.antlr.v4.runtime.tree.TerminalNode;
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.*;
+import java.util.Stack;
+
+import static com.devexperts.logging.Logging.getLogging;
+
+public class CodeWalkthrough {
+    private static final Logging log = getLogging(CodeWalkthrough.class);
+    // inactive statements within inactive branch of code - light red
+    public static final Color INACTIVE_BRANCH = new Color(255, 102, 102);
+    // active statements - light green
+    public static final Color ACTIVE_STATEMENT = new Color(102, 255, 102);
+    // cost past active return statement
+    public static final Color PASSIVE_CODE = Color.lightGray;
+
+    static {
+        log.configureDebugEnabled(true);
+    }
+
+    private static final String CONFIG_MAGIC_PREFIX = "engineConfiguration";
+
+    public static ParseResult applyVariables(VariableValueSource valueSource, String sourceCode, SourceCodePainter painter, ParseTree tree) {
+        Stack<Boolean> currentState = new Stack<>();
+
+        java.util.List<TerminalNode> allTerminals = new java.util.ArrayList<>();
+
+        new ParseTreeWalker().walk(new CPP14ParserBaseListener() {
+            @Override
+            public void enterFunctionDefinition(CPP14Parser.FunctionDefinitionContext ctx) {
+                // new method is starting new all over
+                resetState(currentState);
+            }
+
+            @Override
+            public void enterDeclarationStatement(CPP14Parser.DeclarationStatementContext ctx) {
+                super.enterDeclarationStatement(ctx);
+                colorStatement(ctx, painter);
+            }
+
+            @Override
+            public void enterJumpStatement(CPP14Parser.JumpStatementContext ctx) {
+                super.enterJumpStatement(ctx);
+                colorStatement(ctx, painter);
+                if ("return".equalsIgnoreCase(ctx.getStart().getText()) &&
+                        !currentState.isEmpty() &&
+                        getOverallState(currentState)) {
+                    // we have experienced 'return' in 'green' active flow looks like end of execution for this method?
+                    currentState.clear();
+                }
+            }
+
+            @Override
+            public void enterStatement(CPP14Parser.StatementContext ctx) {
+                String origin = getOrigin(ctx, sourceCode);
+//                System.out.println("enter statement [" + origin + "]");
+            }
+
+            @Override
+            public void visitTerminal(TerminalNode node) {
+                allTerminals.add(node);
+                if ("else".equalsIgnoreCase(node.getSymbol().getText())) {
+                    if (log.debugEnabled())
+                        log.debug("CONDITIONAL ELSE terminal, flipping condition");
+
+                    if (currentState.isEmpty())
+                        return;
+
+                    Boolean onTop = currentState.pop();
+                    currentState.add(!onTop);
+                }
+
+            }
+
+            @Override
+            public void enterCondition(CPP14Parser.ConditionContext ctx) {
+                String conditionVariable = ctx.getText();
+                System.out.println("CONDITIONAL: REQUESTING VALUE " + conditionVariable);
+//                System.out.println("exp " + getOrigin(ctx.expression(), s));
+
+                Boolean state = (Boolean) valueSource.getValue(conditionVariable);
+                if (state == null) {
+                    // todo: fail on unknown condition variables
+                    return;
+                }
+                if (log.debugEnabled())
+                    log.debug("CURRENT STATE ADD " + state);
+                currentState.add(state);
+                if (state) {
+                    painter.paintBackground(Color.GREEN, new Range(ctx));
+                } else {
+                    painter.paintBackground(Color.RED, new Range(ctx));
+                }
+            }
+
+            @Override
+            public void exitSelectionStatement(CPP14Parser.SelectionStatementContext ctx) {
+                super.exitSelectionStatement(ctx);
+                if (currentState.isEmpty())
+                    return; // we are here if some conditional variables were not resolved
+                currentState.pop();
+                if (log.debugEnabled())
+                    log.debug("CONDITIONAL: EXIT");
+            }
+
+
+            private void colorStatement(ParserRuleContext ctx, SourceCodePainter painter) {
+                Color color;
+                if (currentState.isEmpty()) {
+                    color = PASSIVE_CODE; // we are past return or past error
+                } else {
+                    boolean isAlive = getOverallState(currentState);
+                    color = isAlive ? ACTIVE_STATEMENT : INACTIVE_BRANCH;
+                }
+                painter.paintBackground(color, new Range(ctx));
+            }
+        }, tree);
+
+        java.util.List<Token> configTokens = new java.util.ArrayList<>();
+
+        for (int i = 0; i < allTerminals.size() - 3; i++) {
+
+            if (allTerminals.get(i).getText().equals(CONFIG_MAGIC_PREFIX) &&
+                    allTerminals.get(i + 1).getText().equals("->")
+            ) {
+                Token token = allTerminals.get(i + 2).getSymbol();
+                painter.paintForeground(Color.BLUE, new Range(token, token));
+                configTokens.add(token);
+            }
+        }
+        return new ParseResult(configTokens);
+    }
+
+    private static void resetState(Stack<Boolean> currentState) {
+        currentState.clear();
+        currentState.add(Boolean.TRUE);
+    }
+
+    private static boolean getOverallState(Stack<Boolean> currentState) {
+        for (boolean value : currentState) {
+            if (!value)
+                return false;
+        }
+        return true;
+    }
+
+    @NotNull
+    private static String getOrigin(ParserRuleContext ctx, String s) {
+        Range range = new Range(ctx);
+        return s.substring(range.getStart(), range.getStop());
+    }
+}
diff --git a/java_console/ui/src/main/java/com/rusefi/livedata/LiveDataParserPanel.java b/java_console/ui/src/main/java/com/rusefi/livedata/LiveDataParserPanel.java
index e49f3b4e3f..a2abc3e1d6 100644
--- a/java_console/ui/src/main/java/com/rusefi/livedata/LiveDataParserPanel.java
+++ b/java_console/ui/src/main/java/com/rusefi/livedata/LiveDataParserPanel.java
@@ -2,6 +2,7 @@ package com.rusefi.livedata;
 
 import com.devexperts.logging.Logging;
 import com.opensr5.ConfigurationImage;
+import com.rusefi.CodeWalkthrough;
 import com.rusefi.binaryprotocol.BinaryProtocol;
 import com.rusefi.binaryprotocol.BinaryProtocolState;
 import com.rusefi.config.Field;
@@ -9,7 +10,6 @@ import com.rusefi.config.generated.Fields;
 import com.rusefi.enums.live_data_e;
 import com.rusefi.livedata.generated.CPP14Lexer;
 import com.rusefi.livedata.generated.CPP14Parser;
-import com.rusefi.livedata.generated.CPP14ParserBaseListener;
 import com.rusefi.ui.UIContext;
 import com.rusefi.ui.livedata.Range;
 import com.rusefi.ui.livedata.SourceCodePainter;
@@ -19,8 +19,6 @@ import com.rusefi.ui.livedocs.LiveDocsRegistry;
 import com.rusefi.ui.livedocs.RefreshActions;
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
-import org.antlr.v4.runtime.tree.TerminalNode;
 import org.jetbrains.annotations.NotNull;
 
 import javax.swing.*;
@@ -28,7 +26,6 @@ import javax.swing.text.*;
 import java.awt.*;
 import java.io.*;
 import java.net.URISyntaxException;
-import java.util.Stack;
 import java.util.concurrent.atomic.AtomicReference;
 
 import static com.devexperts.logging.Logging.getLogging;
@@ -40,7 +37,6 @@ import static javax.swing.ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED;
  * @see LiveDataParserPanelSandbox
  */
 public class LiveDataParserPanel {
-    private static final String CONFIG_MAGIC_PREFIX = "engineConfiguration";
     private static final Logging log = getLogging(LiveDataParserPanel.class);
 
     {
@@ -134,75 +130,6 @@ public class LiveDataParserPanel {
         return parser.translationUnit();
     }
 
-    public static ParseResult applyVariables(VariableValueSource valueSource, String sourceCode, SourceCodePainter painter, ParseTree tree) {
-        Stack<Boolean> currentState = new Stack<>();
-        currentState.add(Boolean.TRUE);
-
-        java.util.List<TerminalNode> allTerminals = new java.util.ArrayList<>();
-
-        new ParseTreeWalker().walk(new CPP14ParserBaseListener() {
-            @Override
-            public void enterStatement(CPP14Parser.StatementContext ctx) {
-                String origin = getOrigin(ctx, sourceCode);
-//                System.out.println("enter statement [" + origin + "]");
-            }
-
-            @Override
-            public void visitTerminal(TerminalNode node) {
-                allTerminals.add(node);
-            }
-
-            @Override
-            public void enterCondition(CPP14Parser.ConditionContext ctx) {
-                String conditionVariable = ctx.getText();
-//                System.out.println("REQUESTING VALUE " + conditionVariable);
-//                System.out.println("exp " + getOrigin(ctx.expression(), s));
-
-                Boolean state = (Boolean) valueSource.getValue(conditionVariable);
-                if (state == null) {
-                    // todo: fail on unknown condition variables
-                    return;
-                }
-                if (state) {
-                    painter.paintBackground(Color.GREEN, new Range(ctx));
-                } else {
-                    painter.paintBackground(Color.RED, new Range(ctx));
-                }
-            }
-
-            @Override
-            public void enterSelectionStatement(CPP14Parser.SelectionStatementContext ctx) {
-                super.enterSelectionStatement(ctx);
-//                System.out.println("Else terminal " + ctx.Else());
-            }
-
-            @Override
-            public void enterJumpStatement(CPP14Parser.JumpStatementContext ctx) {
-
-            }
-        }, tree);
-
-        java.util.List<Token> configTokens = new java.util.ArrayList<>();
-
-        for (int i = 0; i < allTerminals.size() - 3; i++) {
-
-            if (allTerminals.get(i).getText().equals(CONFIG_MAGIC_PREFIX) &&
-                    allTerminals.get(i + 1).getText().equals("->")
-            ) {
-                Token token = allTerminals.get(i + 2).getSymbol();
-                painter.paintForeground(Color.BLUE, new Range(token, token));
-                configTokens.add(token);
-            }
-        }
-        return new ParseResult(configTokens);
-    }
-
-    @NotNull
-    private static String getOrigin(ParserRuleContext ctx, String s) {
-        Range range = new Range(ctx);
-        return s.substring(range.getStart(), range.getStop());
-    }
-
     public JPanel getContent() {
         return content;
     }
@@ -218,7 +145,7 @@ public class LiveDataParserPanel {
 
         // todo: technically we do not need to do the complete re-compile on fresh data arrival just repaint!
         // todo: split compilation and painting/repainting
-        parseResult = applyVariables(valueSource, sourceCode, new SourceCodePainter() {
+        parseResult = CodeWalkthrough.applyVariables(valueSource, sourceCode, new SourceCodePainter() {
             @Override
             public void paintBackground(Color color, Range range) {
                 AttributeSet s = sc.addAttribute(oldSet, StyleConstants.Background, color);
diff --git a/java_console/ui/src/test/java/com/rusefi/livedata/LiveDataParserSandbox.java b/java_console/ui/src/test/java/com/rusefi/livedata/LiveDataParserSandbox.java
index 1cd27221e0..a92e31b843 100644
--- a/java_console/ui/src/test/java/com/rusefi/livedata/LiveDataParserSandbox.java
+++ b/java_console/ui/src/test/java/com/rusefi/livedata/LiveDataParserSandbox.java
@@ -17,12 +17,7 @@ public class LiveDataParserSandbox {
         values.put("engineTooSlow", Boolean.TRUE);
         values.put("engineTooFast", Boolean.FALSE);
 
-        VariableValueSource valueSource = new VariableValueSource() {
-            @Override
-            public Object getValue(String name) {
-                return values.get(name);
-            }
-        };
+        VariableValueSource valueSource = name -> values.get(name);
 
         new FrameHelper(JDialog.EXIT_ON_CLOSE).showFrame(new LiveDataParserPanel(new UIContext(), valueSource, "ac_control.cpp").getContent());
     }
diff --git a/java_console/ui/src/test/java/com/rusefi/ui/livedata/LiveDataParserTest.java b/java_console/ui/src/test/java/com/rusefi/ui/livedata/LiveDataParserTest.java
index 8b67a8259e..793108410e 100644
--- a/java_console/ui/src/test/java/com/rusefi/ui/livedata/LiveDataParserTest.java
+++ b/java_console/ui/src/test/java/com/rusefi/ui/livedata/LiveDataParserTest.java
@@ -1,5 +1,6 @@
 package com.rusefi.ui.livedata;
 
+import com.rusefi.CodeWalkthrough;
 import com.rusefi.livedata.LiveDataParserPanel;
 import com.rusefi.livedata.LiveDataView;
 import com.rusefi.livedata.ParseResult;
@@ -31,9 +32,8 @@ public class LiveDataParserTest {
         String sourceCode = "bool AcState::getAcState() {\n" +
                 "\tauto rpm = Sensor::getOrZero(SensorType::Rpm);\n" +
                 "\n" +
-                "\tengineTooSlow = rpm < 500;\n" +
-                "\n" +
                 "\tif (engineTooSlow) {\n" +
+                "\t\tinvokeMethod();\n" +
                 "\t\treturn true;\n" +
                 "\t} else {\n  " +
                 "auto ff2 = engineConfiguration->Alternatorcontrolpin;\n" +
@@ -43,18 +43,30 @@ public class LiveDataParserTest {
                 "\t\treturn false;\n" +
                 "\t} \n  " +
                 "return ff;\n" +
-                "}";
+                "}\n" +
+                "bool AcState::getAcState2() {\n" +
+                "return ff;\n" +
+                "}\n";
 
         SourceCodePainter painter = mock(SourceCodePainter.class);
         ParseTree tree = LiveDataParserPanel.getParseTree(sourceCode);
+
+        System.out.println("******************************************* Just print everything for educational purposes");
         new ParseTreeWalker().walk(new PrintCPP14ParserListener(), tree);
 
+        System.out.println("******************************************* Now running FOR REAL");
 
-        LiveDataParserPanel.applyVariables(valueSource, sourceCode, painter, tree);
+
+        CodeWalkthrough.applyVariables(valueSource, sourceCode, painter, tree);
         verify(painter, times(2)).paintForeground(eq(Color.blue), any());
 
         verify(painter).paintBackground(eq(Color.red), any());
         verify(painter).paintBackground(eq(Color.green), any());
+
+        verify(painter, times(4)).paintBackground(eq(CodeWalkthrough.ACTIVE_STATEMENT), any());
+        verify(painter, times(1)).paintBackground(eq(CodeWalkthrough.INACTIVE_BRANCH), any());
+
+        verify(painter, times(3)).paintBackground(eq(CodeWalkthrough.PASSIVE_CODE), any());
     }
 
     @Test
@@ -63,7 +75,7 @@ public class LiveDataParserTest {
         assertTrue(sourceCode.length() > 100);
 
         ParseTree tree = LiveDataParserPanel.getParseTree(sourceCode);
-        ParseResult parseResult = LiveDataParserPanel.applyVariables(VariableValueSource.VOID, sourceCode, SourceCodePainter.VOID, tree);
+        ParseResult parseResult = CodeWalkthrough.applyVariables(VariableValueSource.VOID, sourceCode, SourceCodePainter.VOID, tree);
         assertFalse(parseResult.getConfigTokens().isEmpty());
     }
 }
diff --git a/java_console/ui/src/test/java/com/rusefi/ui/livedata/PrintCPP14ParserListener.java b/java_console/ui/src/test/java/com/rusefi/ui/livedata/PrintCPP14ParserListener.java
index b9bf296551..e9933bca64 100644
--- a/java_console/ui/src/test/java/com/rusefi/ui/livedata/PrintCPP14ParserListener.java
+++ b/java_console/ui/src/test/java/com/rusefi/ui/livedata/PrintCPP14ParserListener.java
@@ -6,2320 +6,2323 @@ import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.tree.ErrorNode;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
-import java.util.Arrays;
-
 public class PrintCPP14ParserListener implements CPP14ParserListener {
+    private int lineCounter = 0;
+
+    private void printWithCounter(String line) {
+        System.out.println(lineCounter++ + " " + line);
+    }
+
     @Override
     public void enterEveryRule(ParserRuleContext parserRuleContext) {
-//        System.out.println("enterEveryRule");
+//        printWithCounter("enterEveryRule");
     }
 
     @Override
     public void exitEveryRule(ParserRuleContext parserRuleContext) {
-//        System.out.println("exitEveryRule");
+//        printWithCounter("exitEveryRule");
     }
 
     @Override
     public void exitTranslationUnit(CPP14Parser.TranslationUnitContext ctx) {
-        System.out.println("exitTranslationUnit");
+        printWithCounter("exitTranslationUnit");
 
     }
 
     @Override
     public void enterTranslationUnit(CPP14Parser.TranslationUnitContext ctx) {
-        System.out.println("enterTranslationUnit");
+        printWithCounter("enterTranslationUnit");
 
     }
 
     @Override
     public void enterPrimaryExpression(CPP14Parser.PrimaryExpressionContext ctx) {
-        System.out.println("enterPrimaryExpression " + ctx.getText());
+        printWithCounter("enterPrimaryExpression " + ctx.getText());
 
     }
 
     @Override
     public void exitPrimaryExpression(CPP14Parser.PrimaryExpressionContext ctx) {
-        System.out.println("exitPrimaryExpression");
+        printWithCounter("exitPrimaryExpression");
 
     }
 
     @Override
     public void enterIdExpression(CPP14Parser.IdExpressionContext ctx) {
-        System.out.println("enterIdExpression");
+        printWithCounter("enterIdExpression");
 
     }
 
     @Override
     public void exitIdExpression(CPP14Parser.IdExpressionContext ctx) {
-        System.out.println("exitIdExpression");
+        printWithCounter("exitIdExpression");
 
     }
 
     @Override
     public void enterUnqualifiedId(CPP14Parser.UnqualifiedIdContext ctx) {
-        System.out.println("enterUnqualifiedId");
+        printWithCounter("enterUnqualifiedId");
 
     }
 
     @Override
     public void exitUnqualifiedId(CPP14Parser.UnqualifiedIdContext ctx) {
-        System.out.println("exitUnqualifiedId");
+        printWithCounter("exitUnqualifiedId");
 
     }
 
     @Override
     public void enterQualifiedId(CPP14Parser.QualifiedIdContext ctx) {
-        System.out.println("enterQualifiedId");
+        printWithCounter("enterQualifiedId");
 
     }
 
     @Override
     public void exitQualifiedId(CPP14Parser.QualifiedIdContext ctx) {
-        System.out.println("exitQualifiedId");
+        printWithCounter("exitQualifiedId");
 
     }
 
     @Override
     public void enterNestedNameSpecifier(CPP14Parser.NestedNameSpecifierContext ctx) {
-        System.out.println("enterNestedNameSpecifier");
+        printWithCounter("enterNestedNameSpecifier");
 
     }
 
     @Override
     public void exitNestedNameSpecifier(CPP14Parser.NestedNameSpecifierContext ctx) {
-        System.out.println("exitNestedNameSpecifier");
+        printWithCounter("exitNestedNameSpecifier");
 
     }
 
     @Override
     public void enterLambdaExpression(CPP14Parser.LambdaExpressionContext ctx) {
-        System.out.println("enterLambdaExpression");
+        printWithCounter("enterLambdaExpression");
 
     }
 
     @Override
     public void exitLambdaExpression(CPP14Parser.LambdaExpressionContext ctx) {
-        System.out.println("exitLambdaExpression");
+        printWithCounter("exitLambdaExpression");
 
     }
 
     @Override
     public void enterLambdaIntroducer(CPP14Parser.LambdaIntroducerContext ctx) {
-        System.out.println("enterLambdaIntroducer");
+        printWithCounter("enterLambdaIntroducer");
 
     }
 
     @Override
     public void exitLambdaIntroducer(CPP14Parser.LambdaIntroducerContext ctx) {
-        System.out.println("exitLambdaIntroducer");
+        printWithCounter("exitLambdaIntroducer");
 
     }
 
     @Override
     public void enterLambdaCapture(CPP14Parser.LambdaCaptureContext ctx) {
-        System.out.println("enterLambdaCapture");
+        printWithCounter("enterLambdaCapture");
 
     }
 
     @Override
     public void exitLambdaCapture(CPP14Parser.LambdaCaptureContext ctx) {
-        System.out.println("exitLambdaCapture");
+        printWithCounter("exitLambdaCapture");
 
     }
 
     @Override
     public void enterCaptureDefault(CPP14Parser.CaptureDefaultContext ctx) {
-        System.out.println("enterCaptureDefault");
+        printWithCounter("enterCaptureDefault");
 
     }
 
     @Override
     public void exitCaptureDefault(CPP14Parser.CaptureDefaultContext ctx) {
-        System.out.println("exitCaptureDefault");
+        printWithCounter("exitCaptureDefault");
 
     }
 
     @Override
     public void enterCaptureList(CPP14Parser.CaptureListContext ctx) {
-        System.out.println("enterCaptureList");
+        printWithCounter("enterCaptureList");
 
     }
 
     @Override
     public void exitCaptureList(CPP14Parser.CaptureListContext ctx) {
-        System.out.println("exitCaptureList");
+        printWithCounter("exitCaptureList");
 
     }
 
     @Override
     public void enterCapture(CPP14Parser.CaptureContext ctx) {
-        System.out.println("enterCapture");
+        printWithCounter("enterCapture");
 
     }
 
     @Override
     public void exitCapture(CPP14Parser.CaptureContext ctx) {
-        System.out.println("exitCapture");
+        printWithCounter("exitCapture");
 
     }
 
     @Override
     public void enterSimpleCapture(CPP14Parser.SimpleCaptureContext ctx) {
-        System.out.println("enterSimpleCapture");
+        printWithCounter("enterSimpleCapture");
 
     }
 
     @Override
     public void exitSimpleCapture(CPP14Parser.SimpleCaptureContext ctx) {
-        System.out.println("exitSimpleCapture");
+        printWithCounter("exitSimpleCapture");
 
     }
 
     @Override
     public void enterInitcapture(CPP14Parser.InitcaptureContext ctx) {
-        System.out.println("enterInitcapture");
+        printWithCounter("enterInitcapture");
 
     }
 
     @Override
     public void exitInitcapture(CPP14Parser.InitcaptureContext ctx) {
-        System.out.println("exitInitcapture");
+        printWithCounter("exitInitcapture");
 
     }
 
     @Override
     public void enterLambdaDeclarator(CPP14Parser.LambdaDeclaratorContext ctx) {
-        System.out.println("enterLambdaDeclarator");
+        printWithCounter("enterLambdaDeclarator");
 
     }
 
     @Override
     public void exitLambdaDeclarator(CPP14Parser.LambdaDeclaratorContext ctx) {
-        System.out.println("exitLambdaDeclarator");
+        printWithCounter("exitLambdaDeclarator");
 
     }
 
     @Override
     public void enterPostfixExpression(CPP14Parser.PostfixExpressionContext ctx) {
-        System.out.println("enterPostfixExpression");
+        printWithCounter("enterPostfixExpression");
 
     }
 
     @Override
     public void exitPostfixExpression(CPP14Parser.PostfixExpressionContext ctx) {
-        System.out.println("exitPostfixExpression");
+        printWithCounter("exitPostfixExpression");
 
     }
 
     @Override
     public void enterTypeIdOfTheTypeId(CPP14Parser.TypeIdOfTheTypeIdContext ctx) {
-        System.out.println("enterTypeIdOfTheTypeId");
+        printWithCounter("enterTypeIdOfTheTypeId");
 
     }
 
     @Override
     public void exitTypeIdOfTheTypeId(CPP14Parser.TypeIdOfTheTypeIdContext ctx) {
-        System.out.println("exitTypeIdOfTheTypeId");
+        printWithCounter("exitTypeIdOfTheTypeId");
 
     }
 
     @Override
     public void enterExpressionList(CPP14Parser.ExpressionListContext ctx) {
-        System.out.println("enterExpressionList");
+        printWithCounter("enterExpressionList");
 
     }
 
     @Override
     public void exitExpressionList(CPP14Parser.ExpressionListContext ctx) {
-        System.out.println("exitExpressionList");
+        printWithCounter("exitExpressionList");
 
     }
 
     @Override
     public void enterPseudoDestructorName(CPP14Parser.PseudoDestructorNameContext ctx) {
-        System.out.println("enterPseudoDestructorName");
+        printWithCounter("enterPseudoDestructorName");
 
     }
 
     @Override
     public void exitPseudoDestructorName(CPP14Parser.PseudoDestructorNameContext ctx) {
-        System.out.println("exitPseudoDestructorName");
+        printWithCounter("exitPseudoDestructorName");
 
     }
 
     @Override
     public void enterUnaryExpression(CPP14Parser.UnaryExpressionContext ctx) {
-        System.out.println("enterUnaryExpression");
+        printWithCounter("enterUnaryExpression");
 
     }
 
     @Override
     public void exitUnaryExpression(CPP14Parser.UnaryExpressionContext ctx) {
-        System.out.println("exitUnaryExpression");
+        printWithCounter("exitUnaryExpression");
 
     }
 
     @Override
     public void enterUnaryOperator(CPP14Parser.UnaryOperatorContext ctx) {
-        System.out.println("enterUnaryOperator");
+        printWithCounter("enterUnaryOperator");
 
     }
 
     @Override
     public void exitUnaryOperator(CPP14Parser.UnaryOperatorContext ctx) {
-        System.out.println("exitUnaryOperator");
+        printWithCounter("exitUnaryOperator");
 
     }
 
     @Override
     public void enterNewExpression(CPP14Parser.NewExpressionContext ctx) {
-        System.out.println("enterNewExpression");
+        printWithCounter("enterNewExpression");
 
     }
 
     @Override
     public void exitNewExpression(CPP14Parser.NewExpressionContext ctx) {
-        System.out.println("exitNewExpression");
+        printWithCounter("exitNewExpression");
 
     }
 
     @Override
     public void enterNewPlacement(CPP14Parser.NewPlacementContext ctx) {
-        System.out.println("enterNewPlacement");
+        printWithCounter("enterNewPlacement");
 
     }
 
     @Override
     public void exitNewPlacement(CPP14Parser.NewPlacementContext ctx) {
-        System.out.println("exitNewPlacement");
+        printWithCounter("exitNewPlacement");
 
     }
 
     @Override
     public void enterNewTypeId(CPP14Parser.NewTypeIdContext ctx) {
-        System.out.println("enterNewTypeId");
+        printWithCounter("enterNewTypeId");
 
     }
 
     @Override
     public void exitNewTypeId(CPP14Parser.NewTypeIdContext ctx) {
-        System.out.println("exitNewTypeId");
+        printWithCounter("exitNewTypeId");
 
     }
 
     @Override
     public void enterNewDeclarator(CPP14Parser.NewDeclaratorContext ctx) {
-        System.out.println("enterNewDeclarator");
+        printWithCounter("enterNewDeclarator");
 
     }
 
     @Override
     public void exitNewDeclarator(CPP14Parser.NewDeclaratorContext ctx) {
-        System.out.println("exitNewDeclarator");
+        printWithCounter("exitNewDeclarator");
 
     }
 
     @Override
     public void enterNoPointerNewDeclarator(CPP14Parser.NoPointerNewDeclaratorContext ctx) {
-        System.out.println("enterNoPointerNewDeclarator");
+        printWithCounter("enterNoPointerNewDeclarator");
 
     }
 
     @Override
     public void exitNoPointerNewDeclarator(CPP14Parser.NoPointerNewDeclaratorContext ctx) {
-        System.out.println("exitNoPointerNewDeclarator");
+        printWithCounter("exitNoPointerNewDeclarator");
 
     }
 
     @Override
     public void enterNewInitializer(CPP14Parser.NewInitializerContext ctx) {
-        System.out.println("enterNewInitializer");
+        printWithCounter("enterNewInitializer");
 
     }
 
     @Override
     public void exitNewInitializer(CPP14Parser.NewInitializerContext ctx) {
-        System.out.println("exitNewInitializer");
+        printWithCounter("exitNewInitializer");
 
     }
 
     @Override
     public void enterDeleteExpression(CPP14Parser.DeleteExpressionContext ctx) {
-        System.out.println("enterDeleteExpression");
+        printWithCounter("enterDeleteExpression");
 
     }
 
     @Override
     public void exitDeleteExpression(CPP14Parser.DeleteExpressionContext ctx) {
-        System.out.println("exitDeleteExpression");
+        printWithCounter("exitDeleteExpression");
 
     }
 
     @Override
     public void enterNoExceptExpression(CPP14Parser.NoExceptExpressionContext ctx) {
-        System.out.println("enterNoExceptExpression");
+        printWithCounter("enterNoExceptExpression");
 
     }
 
     @Override
     public void exitNoExceptExpression(CPP14Parser.NoExceptExpressionContext ctx) {
-        System.out.println("exitNoExceptExpression");
+        printWithCounter("exitNoExceptExpression");
 
     }
 
     @Override
     public void enterCastExpression(CPP14Parser.CastExpressionContext ctx) {
-        System.out.println("enterCastExpression");
+        printWithCounter("enterCastExpression");
 
     }
 
     @Override
     public void exitCastExpression(CPP14Parser.CastExpressionContext ctx) {
-        System.out.println("exitCastExpression");
+        printWithCounter("exitCastExpression");
 
     }
 
     @Override
     public void enterPointerMemberExpression(CPP14Parser.PointerMemberExpressionContext ctx) {
-        System.out.println("enterPointerMemberExpression");
+        printWithCounter("enterPointerMemberExpression");
 
     }
 
     @Override
     public void exitPointerMemberExpression(CPP14Parser.PointerMemberExpressionContext ctx) {
-        System.out.println("exitPointerMemberExpression");
+        printWithCounter("exitPointerMemberExpression");
 
     }
 
     @Override
     public void enterMultiplicativeExpression(CPP14Parser.MultiplicativeExpressionContext ctx) {
-        System.out.println("enterMultiplicativeExpression");
+        printWithCounter("enterMultiplicativeExpression");
 
     }
 
     @Override
     public void exitMultiplicativeExpression(CPP14Parser.MultiplicativeExpressionContext ctx) {
-        System.out.println("exitMultiplicativeExpression");
+        printWithCounter("exitMultiplicativeExpression");
 
     }
 
     @Override
     public void enterAdditiveExpression(CPP14Parser.AdditiveExpressionContext ctx) {
-        System.out.println("enterAdditiveExpression");
+        printWithCounter("enterAdditiveExpression");
 
     }
 
     @Override
     public void exitAdditiveExpression(CPP14Parser.AdditiveExpressionContext ctx) {
-        System.out.println("exitAdditiveExpression");
+        printWithCounter("exitAdditiveExpression");
 
     }
 
     @Override
     public void enterShiftExpression(CPP14Parser.ShiftExpressionContext ctx) {
-        System.out.println("enterShiftExpression");
+        printWithCounter("enterShiftExpression");
 
     }
 
     @Override
     public void exitShiftExpression(CPP14Parser.ShiftExpressionContext ctx) {
-        System.out.println("exitShiftExpression");
+        printWithCounter("exitShiftExpression");
 
     }
 
     @Override
     public void enterShiftOperator(CPP14Parser.ShiftOperatorContext ctx) {
-        System.out.println("enterShiftOperator");
+        printWithCounter("enterShiftOperator");
 
     }
 
     @Override
     public void exitShiftOperator(CPP14Parser.ShiftOperatorContext ctx) {
-        System.out.println("exitShiftOperator");
+        printWithCounter("exitShiftOperator");
 
     }
 
     @Override
     public void enterRelationalExpression(CPP14Parser.RelationalExpressionContext ctx) {
-        System.out.println("enterRelationalExpression");
+        printWithCounter("enterRelationalExpression");
 
     }
 
     @Override
     public void exitRelationalExpression(CPP14Parser.RelationalExpressionContext ctx) {
-        System.out.println("exitRelationalExpression");
+        printWithCounter("exitRelationalExpression");
 
     }
 
     @Override
     public void enterEqualityExpression(CPP14Parser.EqualityExpressionContext ctx) {
-        System.out.println("enterEqualityExpression");
+        printWithCounter("enterEqualityExpression");
 
     }
 
     @Override
     public void exitEqualityExpression(CPP14Parser.EqualityExpressionContext ctx) {
-        System.out.println("exitEqualityExpression");
+        printWithCounter("exitEqualityExpression");
 
     }
 
     @Override
     public void enterAndExpression(CPP14Parser.AndExpressionContext ctx) {
-        System.out.println("enterAndExpression");
+        printWithCounter("enterAndExpression");
 
     }
 
     @Override
     public void exitAndExpression(CPP14Parser.AndExpressionContext ctx) {
-        System.out.println("exitAndExpression");
+        printWithCounter("exitAndExpression");
 
     }
 
     @Override
     public void enterExclusiveOrExpression(CPP14Parser.ExclusiveOrExpressionContext ctx) {
-        System.out.println("enterExclusiveOrExpression");
+        printWithCounter("enterExclusiveOrExpression");
 
     }
 
     @Override
     public void exitExclusiveOrExpression(CPP14Parser.ExclusiveOrExpressionContext ctx) {
-        System.out.println("exitExclusiveOrExpression");
+        printWithCounter("exitExclusiveOrExpression");
 
     }
 
     @Override
     public void enterInclusiveOrExpression(CPP14Parser.InclusiveOrExpressionContext ctx) {
-        System.out.println("enterInclusiveOrExpression");
+        printWithCounter("enterInclusiveOrExpression");
 
     }
 
     @Override
     public void exitInclusiveOrExpression(CPP14Parser.InclusiveOrExpressionContext ctx) {
-        System.out.println("exitInclusiveOrExpression");
+        printWithCounter("exitInclusiveOrExpression");
 
     }
 
     @Override
     public void enterLogicalAndExpression(CPP14Parser.LogicalAndExpressionContext ctx) {
-        System.out.println("enterLogicalAndExpression");
+        printWithCounter("enterLogicalAndExpression");
 
     }
 
     @Override
     public void exitLogicalAndExpression(CPP14Parser.LogicalAndExpressionContext ctx) {
-        System.out.println("exitLogicalAndExpression");
+        printWithCounter("exitLogicalAndExpression");
 
     }
 
     @Override
     public void enterLogicalOrExpression(CPP14Parser.LogicalOrExpressionContext ctx) {
-        System.out.println("enterLogicalOrExpression");
+        printWithCounter("enterLogicalOrExpression");
 
     }
 
     @Override
     public void exitLogicalOrExpression(CPP14Parser.LogicalOrExpressionContext ctx) {
-        System.out.println("exitLogicalOrExpression");
+        printWithCounter("exitLogicalOrExpression");
 
     }
 
     @Override
     public void enterConditionalExpression(CPP14Parser.ConditionalExpressionContext ctx) {
-        System.out.println("enterConditionalExpression");
+        printWithCounter("enterConditionalExpression " + ctx.getText());
 
     }
 
     @Override
     public void exitConditionalExpression(CPP14Parser.ConditionalExpressionContext ctx) {
-        System.out.println("exitConditionalExpression");
+        printWithCounter("exitConditionalExpression");
 
     }
 
     @Override
     public void enterAssignmentExpression(CPP14Parser.AssignmentExpressionContext ctx) {
-        System.out.println("enterAssignmentExpression");
+        printWithCounter("enterAssignmentExpression");
 
     }
 
     @Override
     public void exitAssignmentExpression(CPP14Parser.AssignmentExpressionContext ctx) {
-        System.out.println("exitAssignmentExpression");
+        printWithCounter("exitAssignmentExpression");
 
     }
 
     @Override
     public void enterAssignmentOperator(CPP14Parser.AssignmentOperatorContext ctx) {
-        System.out.println("enterAssignmentOperator");
+        printWithCounter("enterAssignmentOperator");
 
     }
 
     @Override
     public void exitAssignmentOperator(CPP14Parser.AssignmentOperatorContext ctx) {
-        System.out.println("exitAssignmentOperator");
+        printWithCounter("exitAssignmentOperator");
 
     }
 
     @Override
     public void enterExpression(CPP14Parser.ExpressionContext ctx) {
-        System.out.println("enterExpression");
+        printWithCounter("enterExpression");
 
     }
 
     @Override
     public void exitExpression(CPP14Parser.ExpressionContext ctx) {
-        System.out.println("exitExpression");
+        printWithCounter("exitExpression");
 
     }
 
     @Override
     public void enterConstantExpression(CPP14Parser.ConstantExpressionContext ctx) {
-        System.out.println("enterConstantExpression");
+        printWithCounter("enterConstantExpression");
 
     }
 
     @Override
     public void exitConstantExpression(CPP14Parser.ConstantExpressionContext ctx) {
-        System.out.println("exitConstantExpression");
+        printWithCounter("exitConstantExpression");
 
     }
 
     @Override
     public void enterStatement(CPP14Parser.StatementContext ctx) {
-        System.out.println("enterStatement " + ctx.getText());
+        printWithCounter("enterStatement " + ctx.getText());
 
     }
 
     @Override
     public void exitStatement(CPP14Parser.StatementContext ctx) {
-        System.out.println("exitStatement");
+        printWithCounter("exitStatement");
 
     }
 
     @Override
     public void enterLabeledStatement(CPP14Parser.LabeledStatementContext ctx) {
-        System.out.println("enterLabeledStatement");
+        printWithCounter("enterLabeledStatement");
 
     }
 
     @Override
     public void exitLabeledStatement(CPP14Parser.LabeledStatementContext ctx) {
-        System.out.println("exitLabeledStatement");
+        printWithCounter("exitLabeledStatement");
 
     }
 
     @Override
     public void enterExpressionStatement(CPP14Parser.ExpressionStatementContext ctx) {
-        System.out.println("enterExpressionStatement");
+        printWithCounter("enterExpressionStatement");
 
     }
 
     @Override
     public void exitExpressionStatement(CPP14Parser.ExpressionStatementContext ctx) {
-        System.out.println("exitExpressionStatement");
+        printWithCounter("exitExpressionStatement");
 
     }
 
     @Override
     public void enterCompoundStatement(CPP14Parser.CompoundStatementContext ctx) {
-        System.out.println("enterCompoundStatement " + ctx.statementSeq().getText());
+        printWithCounter("enterCompoundStatement " + ctx.statementSeq().getText());
 
     }
 
     @Override
     public void exitCompoundStatement(CPP14Parser.CompoundStatementContext ctx) {
-        System.out.println("exitCompoundStatement");
+        printWithCounter("exitCompoundStatement");
 
     }
 
     @Override
     public void enterStatementSeq(CPP14Parser.StatementSeqContext ctx) {
-        System.out.println("enterStatementSeq");
+        printWithCounter("enterStatementSeq " + ctx.getText());
 
     }
 
     @Override
     public void exitStatementSeq(CPP14Parser.StatementSeqContext ctx) {
-        System.out.println("exitStatementSeq");
+        printWithCounter("exitStatementSeq");
 
     }
 
     @Override
     public void enterSelectionStatement(CPP14Parser.SelectionStatementContext ctx) {
-        System.out.println("enterSelectionStatement " + ctx.getText() + " statements" + ctx.statement());
+        printWithCounter("CONDITIONAL enterSelectionStatement " + ctx.getText() + " statements" + ctx.statement());
 
     }
 
     @Override
     public void exitSelectionStatement(CPP14Parser.SelectionStatementContext ctx) {
-        System.out.println("exitSelectionStatement");
-
+        printWithCounter("CONDITIONAL exitSelectionStatement" + ctx.getText());
     }
 
     @Override
     public void enterCondition(CPP14Parser.ConditionContext ctx) {
-        System.out.println("enterCondition " + ctx.expression().getText());
+        printWithCounter("CONDITIONAL ENTER enterCondition " + ctx.expression().getText());
 
     }
 
     @Override
     public void exitCondition(CPP14Parser.ConditionContext ctx) {
-        System.out.println("exitCondition");
+        printWithCounter("CONDITIONAL exitCondition - end of condition variable");
 
     }
 
     @Override
     public void enterIterationStatement(CPP14Parser.IterationStatementContext ctx) {
-        System.out.println("enterIterationStatement");
+        printWithCounter("enterIterationStatement");
 
     }
 
     @Override
     public void exitIterationStatement(CPP14Parser.IterationStatementContext ctx) {
-        System.out.println("exitIterationStatement");
+        printWithCounter("exitIterationStatement");
 
     }
 
     @Override
     public void enterForInitStatement(CPP14Parser.ForInitStatementContext ctx) {
-        System.out.println("enterForInitStatement");
+        printWithCounter("enterForInitStatement");
 
     }
 
     @Override
     public void exitForInitStatement(CPP14Parser.ForInitStatementContext ctx) {
-        System.out.println("exitForInitStatement");
+        printWithCounter("exitForInitStatement");
 
     }
 
     @Override
     public void enterForRangeDeclaration(CPP14Parser.ForRangeDeclarationContext ctx) {
-        System.out.println("enterForRangeDeclaration");
+        printWithCounter("enterForRangeDeclaration");
 
     }
 
     @Override
     public void exitForRangeDeclaration(CPP14Parser.ForRangeDeclarationContext ctx) {
-        System.out.println("exitForRangeDeclaration");
+        printWithCounter("exitForRangeDeclaration");
 
     }
 
     @Override
     public void enterForRangeInitializer(CPP14Parser.ForRangeInitializerContext ctx) {
-        System.out.println("enterForRangeInitializer");
+        printWithCounter("enterForRangeInitializer");
 
     }
 
     @Override
     public void exitForRangeInitializer(CPP14Parser.ForRangeInitializerContext ctx) {
-        System.out.println("exitForRangeInitializer");
+        printWithCounter("exitForRangeInitializer");
 
     }
 
     @Override
     public void enterJumpStatement(CPP14Parser.JumpStatementContext ctx) {
-        System.out.println("enterJumpStatement " + ctx.getText());
+        printWithCounter("enterJumpStatement " + ctx.getText());
 
     }
 
     @Override
     public void exitJumpStatement(CPP14Parser.JumpStatementContext ctx) {
-        System.out.println("exitJumpStatement");
+        printWithCounter("exitJumpStatement");
 
     }
 
     @Override
     public void enterDeclarationStatement(CPP14Parser.DeclarationStatementContext ctx) {
-        System.out.println("enterDeclarationStatement");
+        printWithCounter("enterDeclarationStatement");
 
     }
 
     @Override
     public void exitDeclarationStatement(CPP14Parser.DeclarationStatementContext ctx) {
-        System.out.println("exitDeclarationStatement");
+        printWithCounter("exitDeclarationStatement");
 
     }
 
     @Override
     public void enterDeclarationseq(CPP14Parser.DeclarationseqContext ctx) {
-        System.out.println("enterDeclarationseq " + ctx);
+        printWithCounter("enterDeclarationseq " + ctx);
 
     }
 
     @Override
     public void exitDeclarationseq(CPP14Parser.DeclarationseqContext ctx) {
-        System.out.println("exitDeclarationseq");
+        printWithCounter("exitDeclarationseq");
 
     }
 
     @Override
     public void enterDeclaration(CPP14Parser.DeclarationContext ctx) {
-        System.out.println("enterDeclaration");
+        printWithCounter("enterDeclaration");
 
     }
 
     @Override
     public void exitDeclaration(CPP14Parser.DeclarationContext ctx) {
-        System.out.println("exitDeclaration");
+        printWithCounter("exitDeclaration");
 
     }
 
     @Override
     public void enterBlockDeclaration(CPP14Parser.BlockDeclarationContext ctx) {
-        System.out.println("enterBlockDeclaration");
+        printWithCounter("enterBlockDeclaration");
 
     }
 
     @Override
     public void exitBlockDeclaration(CPP14Parser.BlockDeclarationContext ctx) {
-        System.out.println("exitBlockDeclaration");
+        printWithCounter("exitBlockDeclaration");
 
     }
 
     @Override
     public void enterAliasDeclaration(CPP14Parser.AliasDeclarationContext ctx) {
-        System.out.println("enterAliasDeclaration");
+        printWithCounter("enterAliasDeclaration");
 
     }
 
     @Override
     public void exitAliasDeclaration(CPP14Parser.AliasDeclarationContext ctx) {
-        System.out.println("exitAliasDeclaration");
+        printWithCounter("exitAliasDeclaration");
 
     }
 
     @Override
     public void enterSimpleDeclaration(CPP14Parser.SimpleDeclarationContext ctx) {
-        System.out.println("enterSimpleDeclaration");
+        printWithCounter("enterSimpleDeclaration");
 
     }
 
     @Override
     public void exitSimpleDeclaration(CPP14Parser.SimpleDeclarationContext ctx) {
-        System.out.println("exitSimpleDeclaration");
+        printWithCounter("exitSimpleDeclaration");
 
     }
 
     @Override
     public void enterStaticAssertDeclaration(CPP14Parser.StaticAssertDeclarationContext ctx) {
-        System.out.println("enterStaticAssertDeclaration");
+        printWithCounter("enterStaticAssertDeclaration");
 
     }
 
     @Override
     public void exitStaticAssertDeclaration(CPP14Parser.StaticAssertDeclarationContext ctx) {
-        System.out.println("exitStaticAssertDeclaration");
+        printWithCounter("exitStaticAssertDeclaration");
 
     }
 
     @Override
     public void enterEmptyDeclaration(CPP14Parser.EmptyDeclarationContext ctx) {
-        System.out.println("enterEmptyDeclaration");
+        printWithCounter("enterEmptyDeclaration");
 
     }
 
     @Override
     public void exitEmptyDeclaration(CPP14Parser.EmptyDeclarationContext ctx) {
-        System.out.println("exitEmptyDeclaration");
+        printWithCounter("exitEmptyDeclaration");
 
     }
 
     @Override
     public void enterAttributeDeclaration(CPP14Parser.AttributeDeclarationContext ctx) {
-        System.out.println("enterAttributeDeclaration");
+        printWithCounter("enterAttributeDeclaration");
 
     }
 
     @Override
     public void exitAttributeDeclaration(CPP14Parser.AttributeDeclarationContext ctx) {
-        System.out.println("exitAttributeDeclaration");
+        printWithCounter("exitAttributeDeclaration");
 
     }
 
     @Override
     public void enterDeclSpecifier(CPP14Parser.DeclSpecifierContext ctx) {
-        System.out.println("enterDeclSpecifier");
+        printWithCounter("enterDeclSpecifier");
 
     }
 
     @Override
     public void exitDeclSpecifier(CPP14Parser.DeclSpecifierContext ctx) {
-        System.out.println("exitDeclSpecifier");
+        printWithCounter("exitDeclSpecifier");
 
     }
 
     @Override
     public void enterDeclSpecifierSeq(CPP14Parser.DeclSpecifierSeqContext ctx) {
-        System.out.println("enterDeclSpecifierSeq");
+        printWithCounter("enterDeclSpecifierSeq");
 
     }
 
     @Override
     public void exitDeclSpecifierSeq(CPP14Parser.DeclSpecifierSeqContext ctx) {
-        System.out.println("exitDeclSpecifierSeq");
+        printWithCounter("exitDeclSpecifierSeq");
 
     }
 
     @Override
     public void enterStorageClassSpecifier(CPP14Parser.StorageClassSpecifierContext ctx) {
-        System.out.println("enterStorageClassSpecifier");
+        printWithCounter("enterStorageClassSpecifier");
 
     }
 
     @Override
     public void exitStorageClassSpecifier(CPP14Parser.StorageClassSpecifierContext ctx) {
-        System.out.println("exitStorageClassSpecifier");
+        printWithCounter("exitStorageClassSpecifier");
 
     }
 
     @Override
     public void enterFunctionSpecifier(CPP14Parser.FunctionSpecifierContext ctx) {
-        System.out.println("enterFunctionSpecifier");
+        printWithCounter("enterFunctionSpecifier");
 
     }
 
     @Override
     public void exitFunctionSpecifier(CPP14Parser.FunctionSpecifierContext ctx) {
-        System.out.println("exitFunctionSpecifier");
+        printWithCounter("exitFunctionSpecifier");
 
     }
 
     @Override
     public void enterTypedefName(CPP14Parser.TypedefNameContext ctx) {
-        System.out.println("enterTypedefName");
+        printWithCounter("enterTypedefName");
 
     }
 
     @Override
     public void exitTypedefName(CPP14Parser.TypedefNameContext ctx) {
-        System.out.println("exitTypedefName");
+        printWithCounter("exitTypedefName");
 
     }
 
     @Override
     public void enterTypeSpecifier(CPP14Parser.TypeSpecifierContext ctx) {
-        System.out.println("enterTypeSpecifier");
+        printWithCounter("enterTypeSpecifier");
 
     }
 
     @Override
     public void exitTypeSpecifier(CPP14Parser.TypeSpecifierContext ctx) {
-        System.out.println("exitTypeSpecifier");
+        printWithCounter("exitTypeSpecifier");
 
     }
 
     @Override
     public void enterTrailingTypeSpecifier(CPP14Parser.TrailingTypeSpecifierContext ctx) {
-        System.out.println("enterTrailingTypeSpecifier");
+        printWithCounter("enterTrailingTypeSpecifier");
 
     }
 
     @Override
     public void exitTrailingTypeSpecifier(CPP14Parser.TrailingTypeSpecifierContext ctx) {
-        System.out.println("exitTrailingTypeSpecifier");
+        printWithCounter("exitTrailingTypeSpecifier");
 
     }
 
     @Override
     public void enterTypeSpecifierSeq(CPP14Parser.TypeSpecifierSeqContext ctx) {
-        System.out.println("enterTypeSpecifierSeq");
+        printWithCounter("enterTypeSpecifierSeq");
 
     }
 
     @Override
     public void exitTypeSpecifierSeq(CPP14Parser.TypeSpecifierSeqContext ctx) {
-        System.out.println("exitTypeSpecifierSeq");
+        printWithCounter("exitTypeSpecifierSeq");
 
     }
 
     @Override
     public void enterTrailingTypeSpecifierSeq(CPP14Parser.TrailingTypeSpecifierSeqContext ctx) {
-        System.out.println("enterTrailingTypeSpecifierSeq");
+        printWithCounter("enterTrailingTypeSpecifierSeq");
 
     }
 
     @Override
     public void exitTrailingTypeSpecifierSeq(CPP14Parser.TrailingTypeSpecifierSeqContext ctx) {
-        System.out.println("exitTrailingTypeSpecifierSeq");
+        printWithCounter("exitTrailingTypeSpecifierSeq");
 
     }
 
     @Override
     public void enterSimpleTypeLengthModifier(CPP14Parser.SimpleTypeLengthModifierContext ctx) {
-        System.out.println("enterSimpleTypeLengthModifier");
+        printWithCounter("enterSimpleTypeLengthModifier");
 
     }
 
     @Override
     public void exitSimpleTypeLengthModifier(CPP14Parser.SimpleTypeLengthModifierContext ctx) {
-        System.out.println("exitSimpleTypeLengthModifier");
+        printWithCounter("exitSimpleTypeLengthModifier");
 
     }
 
     @Override
     public void enterSimpleTypeSignednessModifier(CPP14Parser.SimpleTypeSignednessModifierContext ctx) {
-        System.out.println("enterSimpleTypeSignednessModifier");
+        printWithCounter("enterSimpleTypeSignednessModifier");
 
     }
 
     @Override
     public void exitSimpleTypeSignednessModifier(CPP14Parser.SimpleTypeSignednessModifierContext ctx) {
-        System.out.println("exitSimpleTypeSignednessModifier");
+        printWithCounter("exitSimpleTypeSignednessModifier");
 
     }
 
     @Override
     public void enterSimpleTypeSpecifier(CPP14Parser.SimpleTypeSpecifierContext ctx) {
-        System.out.println("enterSimpleTypeSpecifier");
+        printWithCounter("enterSimpleTypeSpecifier");
 
     }
 
     @Override
     public void exitSimpleTypeSpecifier(CPP14Parser.SimpleTypeSpecifierContext ctx) {
-        System.out.println("exitSimpleTypeSpecifier");
+        printWithCounter("exitSimpleTypeSpecifier");
 
     }
 
     @Override
     public void enterTheTypeName(CPP14Parser.TheTypeNameContext ctx) {
-        System.out.println("enterTheTypeName");
+        printWithCounter("enterTheTypeName");
 
     }
 
     @Override
     public void exitTheTypeName(CPP14Parser.TheTypeNameContext ctx) {
-        System.out.println("exitTheTypeName");
+        printWithCounter("exitTheTypeName");
 
     }
 
     @Override
     public void enterDecltypeSpecifier(CPP14Parser.DecltypeSpecifierContext ctx) {
-        System.out.println("enterDecltypeSpecifier");
+        printWithCounter("enterDecltypeSpecifier");
 
     }
 
     @Override
     public void exitDecltypeSpecifier(CPP14Parser.DecltypeSpecifierContext ctx) {
-        System.out.println("exitDecltypeSpecifier");
+        printWithCounter("exitDecltypeSpecifier");
 
     }
 
     @Override
     public void enterElaboratedTypeSpecifier(CPP14Parser.ElaboratedTypeSpecifierContext ctx) {
-        System.out.println("enterElaboratedTypeSpecifier");
+        printWithCounter("enterElaboratedTypeSpecifier");
 
     }
 
     @Override
     public void exitElaboratedTypeSpecifier(CPP14Parser.ElaboratedTypeSpecifierContext ctx) {
-        System.out.println("exitElaboratedTypeSpecifier");
+        printWithCounter("exitElaboratedTypeSpecifier");
 
     }
 
     @Override
     public void enterEnumName(CPP14Parser.EnumNameContext ctx) {
-        System.out.println("enterEnumName");
+        printWithCounter("enterEnumName");
 
     }
 
     @Override
     public void exitEnumName(CPP14Parser.EnumNameContext ctx) {
-        System.out.println("exitEnumName");
+        printWithCounter("exitEnumName");
 
     }
 
     @Override
     public void enterEnumSpecifier(CPP14Parser.EnumSpecifierContext ctx) {
-        System.out.println("enterEnumSpecifier");
+        printWithCounter("enterEnumSpecifier");
 
     }
 
     @Override
     public void exitEnumSpecifier(CPP14Parser.EnumSpecifierContext ctx) {
-        System.out.println("exitEnumSpecifier");
+        printWithCounter("exitEnumSpecifier");
 
     }
 
     @Override
     public void enterEnumHead(CPP14Parser.EnumHeadContext ctx) {
-        System.out.println("enterEnumHead");
+        printWithCounter("enterEnumHead");
 
     }
 
     @Override
     public void exitEnumHead(CPP14Parser.EnumHeadContext ctx) {
-        System.out.println("exitEnumHead");
+        printWithCounter("exitEnumHead");
 
     }
 
     @Override
     public void enterOpaqueEnumDeclaration(CPP14Parser.OpaqueEnumDeclarationContext ctx) {
-        System.out.println("enterOpaqueEnumDeclaration");
+        printWithCounter("enterOpaqueEnumDeclaration");
 
     }
 
     @Override
     public void exitOpaqueEnumDeclaration(CPP14Parser.OpaqueEnumDeclarationContext ctx) {
-        System.out.println("exitOpaqueEnumDeclaration");
+        printWithCounter("exitOpaqueEnumDeclaration");
 
     }
 
     @Override
     public void enterEnumkey(CPP14Parser.EnumkeyContext ctx) {
-        System.out.println("enterEnumkey");
+        printWithCounter("enterEnumkey");
 
     }
 
     @Override
     public void exitEnumkey(CPP14Parser.EnumkeyContext ctx) {
-        System.out.println("exitEnumkey");
+        printWithCounter("exitEnumkey");
 
     }
 
     @Override
     public void enterEnumbase(CPP14Parser.EnumbaseContext ctx) {
-        System.out.println("enterEnumbase");
+        printWithCounter("enterEnumbase");
 
     }
 
     @Override
     public void exitEnumbase(CPP14Parser.EnumbaseContext ctx) {
-        System.out.println("exitEnumbase");
+        printWithCounter("exitEnumbase");
 
     }
 
     @Override
     public void enterEnumeratorList(CPP14Parser.EnumeratorListContext ctx) {
-        System.out.println("enterEnumeratorList");
+        printWithCounter("enterEnumeratorList");
 
     }
 
     @Override
     public void exitEnumeratorList(CPP14Parser.EnumeratorListContext ctx) {
-        System.out.println("exitEnumeratorList");
+        printWithCounter("exitEnumeratorList");
 
     }
 
     @Override
     public void enterEnumeratorDefinition(CPP14Parser.EnumeratorDefinitionContext ctx) {
-        System.out.println("enterEnumeratorDefinition");
+        printWithCounter("enterEnumeratorDefinition");
 
     }
 
     @Override
     public void exitEnumeratorDefinition(CPP14Parser.EnumeratorDefinitionContext ctx) {
-        System.out.println("exitEnumeratorDefinition");
+        printWithCounter("exitEnumeratorDefinition");
 
     }
 
     @Override
     public void enterEnumerator(CPP14Parser.EnumeratorContext ctx) {
-        System.out.println("enterEnumerator");
+        printWithCounter("enterEnumerator");
 
     }
 
     @Override
     public void exitEnumerator(CPP14Parser.EnumeratorContext ctx) {
-        System.out.println("exitEnumerator");
+        printWithCounter("exitEnumerator");
 
     }
 
     @Override
     public void enterNamespaceName(CPP14Parser.NamespaceNameContext ctx) {
-        System.out.println("enterNamespaceName");
+        printWithCounter("enterNamespaceName");
 
     }
 
     @Override
     public void exitNamespaceName(CPP14Parser.NamespaceNameContext ctx) {
-        System.out.println("exitNamespaceName");
+        printWithCounter("exitNamespaceName");
 
     }
 
     @Override
     public void enterOriginalNamespaceName(CPP14Parser.OriginalNamespaceNameContext ctx) {
-        System.out.println("enterOriginalNamespaceName");
+        printWithCounter("enterOriginalNamespaceName");
 
     }
 
     @Override
     public void exitOriginalNamespaceName(CPP14Parser.OriginalNamespaceNameContext ctx) {
-        System.out.println("exitOriginalNamespaceName");
+        printWithCounter("exitOriginalNamespaceName");
 
     }
 
     @Override
     public void enterNamespaceDefinition(CPP14Parser.NamespaceDefinitionContext ctx) {
-        System.out.println("enterNamespaceDefinition");
+        printWithCounter("enterNamespaceDefinition");
 
     }
 
     @Override
     public void exitNamespaceDefinition(CPP14Parser.NamespaceDefinitionContext ctx) {
-        System.out.println("exitNamespaceDefinition");
+        printWithCounter("exitNamespaceDefinition");
 
     }
 
     @Override
     public void enterNamespaceAlias(CPP14Parser.NamespaceAliasContext ctx) {
-        System.out.println("enterNamespaceAlias");
+        printWithCounter("enterNamespaceAlias");
 
     }
 
     @Override
     public void exitNamespaceAlias(CPP14Parser.NamespaceAliasContext ctx) {
-        System.out.println("exitNamespaceAlias");
+        printWithCounter("exitNamespaceAlias");
 
     }
 
     @Override
     public void enterNamespaceAliasDefinition(CPP14Parser.NamespaceAliasDefinitionContext ctx) {
-        System.out.println("enterNamespaceAliasDefinition");
+        printWithCounter("enterNamespaceAliasDefinition");
 
     }
 
     @Override
     public void exitNamespaceAliasDefinition(CPP14Parser.NamespaceAliasDefinitionContext ctx) {
-        System.out.println("exitNamespaceAliasDefinition");
+        printWithCounter("exitNamespaceAliasDefinition");
 
     }
 
     @Override
     public void enterQualifiednamespacespecifier(CPP14Parser.QualifiednamespacespecifierContext ctx) {
-        System.out.println("enterQualifiednamespacespecifier");
+        printWithCounter("enterQualifiednamespacespecifier");
 
     }
 
     @Override
     public void exitQualifiednamespacespecifier(CPP14Parser.QualifiednamespacespecifierContext ctx) {
-        System.out.println("exitQualifiednamespacespecifier");
+        printWithCounter("exitQualifiednamespacespecifier");
 
     }
 
     @Override
     public void enterUsingDeclaration(CPP14Parser.UsingDeclarationContext ctx) {
-        System.out.println("enterUsingDeclaration");
+        printWithCounter("enterUsingDeclaration");
 
     }
 
     @Override
     public void exitUsingDeclaration(CPP14Parser.UsingDeclarationContext ctx) {
-        System.out.println("exitUsingDeclaration");
+        printWithCounter("exitUsingDeclaration");
 
     }
 
     @Override
     public void enterUsingDirective(CPP14Parser.UsingDirectiveContext ctx) {
-        System.out.println("enterUsingDirective");
+        printWithCounter("enterUsingDirective");
 
     }
 
     @Override
     public void exitUsingDirective(CPP14Parser.UsingDirectiveContext ctx) {
-        System.out.println("exitUsingDirective");
+        printWithCounter("exitUsingDirective");
 
     }
 
     @Override
     public void enterAsmDefinition(CPP14Parser.AsmDefinitionContext ctx) {
-        System.out.println("enterAsmDefinition");
+        printWithCounter("enterAsmDefinition");
 
     }
 
     @Override
     public void exitAsmDefinition(CPP14Parser.AsmDefinitionContext ctx) {
-        System.out.println("exitAsmDefinition");
+        printWithCounter("exitAsmDefinition");
 
     }
 
     @Override
     public void enterLinkageSpecification(CPP14Parser.LinkageSpecificationContext ctx) {
-        System.out.println("enterLinkageSpecification");
+        printWithCounter("enterLinkageSpecification");
 
     }
 
     @Override
     public void exitLinkageSpecification(CPP14Parser.LinkageSpecificationContext ctx) {
-        System.out.println("exitLinkageSpecification");
+        printWithCounter("exitLinkageSpecification");
 
     }
 
     @Override
     public void enterAttributeSpecifierSeq(CPP14Parser.AttributeSpecifierSeqContext ctx) {
-        System.out.println("enterAttributeSpecifierSeq");
+        printWithCounter("enterAttributeSpecifierSeq");
 
     }
 
     @Override
     public void exitAttributeSpecifierSeq(CPP14Parser.AttributeSpecifierSeqContext ctx) {
-        System.out.println("exitAttributeSpecifierSeq");
+        printWithCounter("exitAttributeSpecifierSeq");
 
     }
 
     @Override
     public void enterAttributeSpecifier(CPP14Parser.AttributeSpecifierContext ctx) {
-        System.out.println("enterAttributeSpecifier");
+        printWithCounter("enterAttributeSpecifier");
 
     }
 
     @Override
     public void exitAttributeSpecifier(CPP14Parser.AttributeSpecifierContext ctx) {
-        System.out.println("exitAttributeSpecifier");
+        printWithCounter("exitAttributeSpecifier");
 
     }
 
     @Override
     public void enterAlignmentspecifier(CPP14Parser.AlignmentspecifierContext ctx) {
-        System.out.println("enterAlignmentspecifier");
+        printWithCounter("enterAlignmentspecifier");
 
     }
 
     @Override
     public void exitAlignmentspecifier(CPP14Parser.AlignmentspecifierContext ctx) {
-        System.out.println("exitAlignmentspecifier");
+        printWithCounter("exitAlignmentspecifier");
 
     }
 
     @Override
     public void enterAttributeList(CPP14Parser.AttributeListContext ctx) {
-        System.out.println("enterAttributeList");
+        printWithCounter("enterAttributeList");
 
     }
 
     @Override
     public void exitAttributeList(CPP14Parser.AttributeListContext ctx) {
-        System.out.println("exitAttributeList");
+        printWithCounter("exitAttributeList");
 
     }
 
     @Override
     public void enterAttribute(CPP14Parser.AttributeContext ctx) {
-        System.out.println("enterAttribute");
+        printWithCounter("enterAttribute");
 
     }
 
     @Override
     public void exitAttribute(CPP14Parser.AttributeContext ctx) {
-        System.out.println("exitAttribute");
+        printWithCounter("exitAttribute");
 
     }
 
     @Override
     public void enterAttributeNamespace(CPP14Parser.AttributeNamespaceContext ctx) {
-        System.out.println("enterAttributeNamespace");
+        printWithCounter("enterAttributeNamespace");
 
     }
 
     @Override
     public void exitAttributeNamespace(CPP14Parser.AttributeNamespaceContext ctx) {
-        System.out.println("exitAttributeNamespace");
+        printWithCounter("exitAttributeNamespace");
 
     }
 
     @Override
     public void enterAttributeArgumentClause(CPP14Parser.AttributeArgumentClauseContext ctx) {
-        System.out.println("enterAttributeArgumentClause");
+        printWithCounter("enterAttributeArgumentClause");
 
     }
 
     @Override
     public void exitAttributeArgumentClause(CPP14Parser.AttributeArgumentClauseContext ctx) {
-        System.out.println("exitAttributeArgumentClause");
+        printWithCounter("exitAttributeArgumentClause");
 
     }
 
     @Override
     public void enterBalancedTokenSeq(CPP14Parser.BalancedTokenSeqContext ctx) {
-        System.out.println("enterBalancedTokenSeq");
+        printWithCounter("enterBalancedTokenSeq");
 
     }
 
     @Override
     public void exitBalancedTokenSeq(CPP14Parser.BalancedTokenSeqContext ctx) {
-        System.out.println("exitBalancedTokenSeq");
+        printWithCounter("exitBalancedTokenSeq");
 
     }
 
     @Override
     public void enterBalancedtoken(CPP14Parser.BalancedtokenContext ctx) {
-        System.out.println("enterBalancedtoken");
+        printWithCounter("enterBalancedtoken");
 
     }
 
     @Override
     public void exitBalancedtoken(CPP14Parser.BalancedtokenContext ctx) {
-        System.out.println("exitBalancedtoken");
+        printWithCounter("exitBalancedtoken");
 
     }
 
     @Override
     public void enterInitDeclaratorList(CPP14Parser.InitDeclaratorListContext ctx) {
-        System.out.println("enterInitDeclaratorList");
+        printWithCounter("enterInitDeclaratorList");
 
     }
 
     @Override
     public void exitInitDeclaratorList(CPP14Parser.InitDeclaratorListContext ctx) {
-        System.out.println("exitInitDeclaratorList");
+        printWithCounter("exitInitDeclaratorList");
 
     }
 
     @Override
     public void enterInitDeclarator(CPP14Parser.InitDeclaratorContext ctx) {
-        System.out.println("enterInitDeclarator");
+        printWithCounter("enterInitDeclarator");
 
     }
 
     @Override
     public void exitInitDeclarator(CPP14Parser.InitDeclaratorContext ctx) {
-        System.out.println("exitInitDeclarator");
+        printWithCounter("exitInitDeclarator");
 
     }
 
     @Override
     public void enterDeclarator(CPP14Parser.DeclaratorContext ctx) {
-        System.out.println("enterDeclarator " + ctx.pointerDeclarator().getText());
+        printWithCounter("enterDeclarator " + ctx.pointerDeclarator().getText());
 
     }
 
     @Override
     public void exitDeclarator(CPP14Parser.DeclaratorContext ctx) {
-        System.out.println("exitDeclarator");
+        printWithCounter("exitDeclarator");
 
     }
 
     @Override
     public void enterPointerDeclarator(CPP14Parser.PointerDeclaratorContext ctx) {
-        System.out.println("enterPointerDeclarator");
+        printWithCounter("enterPointerDeclarator");
 
     }
 
     @Override
     public void exitPointerDeclarator(CPP14Parser.PointerDeclaratorContext ctx) {
-        System.out.println("exitPointerDeclarator");
+        printWithCounter("exitPointerDeclarator");
 
     }
 
     @Override
     public void enterNoPointerDeclarator(CPP14Parser.NoPointerDeclaratorContext ctx) {
-        System.out.println("enterNoPointerDeclarator");
+        printWithCounter("enterNoPointerDeclarator");
 
     }
 
     @Override
     public void exitNoPointerDeclarator(CPP14Parser.NoPointerDeclaratorContext ctx) {
-        System.out.println("exitNoPointerDeclarator");
+        printWithCounter("exitNoPointerDeclarator");
 
     }
 
     @Override
     public void enterParametersAndQualifiers(CPP14Parser.ParametersAndQualifiersContext ctx) {
-        System.out.println("enterParametersAndQualifiers");
+        printWithCounter("enterParametersAndQualifiers");
 
     }
 
     @Override
     public void exitParametersAndQualifiers(CPP14Parser.ParametersAndQualifiersContext ctx) {
-        System.out.println("exitParametersAndQualifiers");
+        printWithCounter("exitParametersAndQualifiers");
 
     }
 
     @Override
     public void enterTrailingReturnType(CPP14Parser.TrailingReturnTypeContext ctx) {
-        System.out.println("enterTrailingReturnType");
+        printWithCounter("enterTrailingReturnType");
 
     }
 
     @Override
     public void exitTrailingReturnType(CPP14Parser.TrailingReturnTypeContext ctx) {
-        System.out.println("exitTrailingReturnType");
+        printWithCounter("exitTrailingReturnType");
 
     }
 
     @Override
     public void enterPointerOperator(CPP14Parser.PointerOperatorContext ctx) {
-        System.out.println("enterPointerOperator");
+        printWithCounter("enterPointerOperator");
 
     }
 
     @Override
     public void exitPointerOperator(CPP14Parser.PointerOperatorContext ctx) {
-        System.out.println("exitPointerOperator");
+        printWithCounter("exitPointerOperator");
 
     }
 
     @Override
     public void enterCvqualifierseq(CPP14Parser.CvqualifierseqContext ctx) {
-        System.out.println("enterCvqualifierseq");
+        printWithCounter("enterCvqualifierseq");
 
     }
 
     @Override
     public void exitCvqualifierseq(CPP14Parser.CvqualifierseqContext ctx) {
-        System.out.println("exitCvqualifierseq");
+        printWithCounter("exitCvqualifierseq");
 
     }
 
     @Override
     public void enterCvQualifier(CPP14Parser.CvQualifierContext ctx) {
-        System.out.println("enterCvQualifier");
+        printWithCounter("enterCvQualifier");
 
     }
 
     @Override
     public void exitCvQualifier(CPP14Parser.CvQualifierContext ctx) {
-        System.out.println("exitCvQualifier");
+        printWithCounter("exitCvQualifier");
 
     }
 
     @Override
     public void enterRefqualifier(CPP14Parser.RefqualifierContext ctx) {
-        System.out.println("enterRefqualifier");
+        printWithCounter("enterRefqualifier");
 
     }
 
     @Override
     public void exitRefqualifier(CPP14Parser.RefqualifierContext ctx) {
-        System.out.println("exitRefqualifier");
+        printWithCounter("exitRefqualifier");
 
     }
 
     @Override
     public void enterDeclaratorid(CPP14Parser.DeclaratoridContext ctx) {
-        System.out.println("enterDeclaratorid");
+        printWithCounter("enterDeclaratorid");
 
     }
 
     @Override
     public void exitDeclaratorid(CPP14Parser.DeclaratoridContext ctx) {
-        System.out.println("exitDeclaratorid");
+        printWithCounter("exitDeclaratorid");
 
     }
 
     @Override
     public void enterTheTypeId(CPP14Parser.TheTypeIdContext ctx) {
-        System.out.println("enterTheTypeId");
+        printWithCounter("enterTheTypeId");
 
     }
 
     @Override
     public void exitTheTypeId(CPP14Parser.TheTypeIdContext ctx) {
-        System.out.println("exitTheTypeId");
+        printWithCounter("exitTheTypeId");
 
     }
 
     @Override
     public void enterAbstractDeclarator(CPP14Parser.AbstractDeclaratorContext ctx) {
-        System.out.println("enterAbstractDeclarator");
+        printWithCounter("enterAbstractDeclarator");
 
     }
 
     @Override
     public void exitAbstractDeclarator(CPP14Parser.AbstractDeclaratorContext ctx) {
-        System.out.println("exitAbstractDeclarator");
+        printWithCounter("exitAbstractDeclarator");
 
     }
 
     @Override
     public void enterPointerAbstractDeclarator(CPP14Parser.PointerAbstractDeclaratorContext ctx) {
-        System.out.println("enterPointerAbstractDeclarator");
+        printWithCounter("enterPointerAbstractDeclarator");
 
     }
 
     @Override
     public void exitPointerAbstractDeclarator(CPP14Parser.PointerAbstractDeclaratorContext ctx) {
-        System.out.println("exitPointerAbstractDeclarator");
+        printWithCounter("exitPointerAbstractDeclarator");
 
     }
 
     @Override
     public void enterNoPointerAbstractDeclarator(CPP14Parser.NoPointerAbstractDeclaratorContext ctx) {
-        System.out.println("enterNoPointerAbstractDeclarator");
+        printWithCounter("enterNoPointerAbstractDeclarator");
 
     }
 
     @Override
     public void exitNoPointerAbstractDeclarator(CPP14Parser.NoPointerAbstractDeclaratorContext ctx) {
-        System.out.println("exitNoPointerAbstractDeclarator");
+        printWithCounter("exitNoPointerAbstractDeclarator");
 
     }
 
     @Override
     public void enterAbstractPackDeclarator(CPP14Parser.AbstractPackDeclaratorContext ctx) {
-        System.out.println("enterAbstractPackDeclarator");
+        printWithCounter("enterAbstractPackDeclarator");
 
     }
 
     @Override
     public void exitAbstractPackDeclarator(CPP14Parser.AbstractPackDeclaratorContext ctx) {
-        System.out.println("exitAbstractPackDeclarator");
+        printWithCounter("exitAbstractPackDeclarator");
 
     }
 
     @Override
     public void enterNoPointerAbstractPackDeclarator(CPP14Parser.NoPointerAbstractPackDeclaratorContext ctx) {
-        System.out.println("enterNoPointerAbstractPackDeclarator");
+        printWithCounter("enterNoPointerAbstractPackDeclarator");
 
     }
 
     @Override
     public void exitNoPointerAbstractPackDeclarator(CPP14Parser.NoPointerAbstractPackDeclaratorContext ctx) {
-        System.out.println("exitNoPointerAbstractPackDeclarator");
+        printWithCounter("exitNoPointerAbstractPackDeclarator");
 
     }
 
     @Override
     public void enterParameterDeclarationClause(CPP14Parser.ParameterDeclarationClauseContext ctx) {
-        System.out.println("enterParameterDeclarationClause");
+        printWithCounter("enterParameterDeclarationClause");
 
     }
 
     @Override
     public void exitParameterDeclarationClause(CPP14Parser.ParameterDeclarationClauseContext ctx) {
-        System.out.println("exitParameterDeclarationClause");
+        printWithCounter("exitParameterDeclarationClause");
 
     }
 
     @Override
     public void enterParameterDeclarationList(CPP14Parser.ParameterDeclarationListContext ctx) {
-        System.out.println("enterParameterDeclarationList");
+        printWithCounter("enterParameterDeclarationList");
 
     }
 
     @Override
     public void exitParameterDeclarationList(CPP14Parser.ParameterDeclarationListContext ctx) {
-        System.out.println("exitParameterDeclarationList");
+        printWithCounter("exitParameterDeclarationList");
 
     }
 
     @Override
     public void enterParameterDeclaration(CPP14Parser.ParameterDeclarationContext ctx) {
-        System.out.println("enterParameterDeclaration");
+        printWithCounter("enterParameterDeclaration");
 
     }
 
     @Override
     public void exitParameterDeclaration(CPP14Parser.ParameterDeclarationContext ctx) {
-        System.out.println("exitParameterDeclaration");
+        printWithCounter("exitParameterDeclaration");
 
     }
 
     @Override
     public void enterFunctionDefinition(CPP14Parser.FunctionDefinitionContext ctx) {
-        System.out.println("enterFunctionDefinition " + ctx + " " + ctx.declarator().getText());
+        printWithCounter("enterFunctionDefinition " + ctx + " " + ctx.declarator().getText());
 
     }
 
     @Override
     public void exitFunctionDefinition(CPP14Parser.FunctionDefinitionContext ctx) {
-        System.out.println("exitFunctionDefinition");
+        printWithCounter("exitFunctionDefinition");
 
     }
 
     @Override
     public void enterFunctionBody(CPP14Parser.FunctionBodyContext ctx) {
-        System.out.println("enterFunctionBody");
+        printWithCounter("enterFunctionBody");
 
     }
 
     @Override
     public void exitFunctionBody(CPP14Parser.FunctionBodyContext ctx) {
-        System.out.println("exitFunctionBody");
+        printWithCounter("exitFunctionBody");
 
     }
 
     @Override
     public void enterInitializer(CPP14Parser.InitializerContext ctx) {
-        System.out.println("enterInitializer");
+        printWithCounter("enterInitializer");
 
     }
 
     @Override
     public void exitInitializer(CPP14Parser.InitializerContext ctx) {
-        System.out.println("exitInitializer");
+        printWithCounter("exitInitializer");
 
     }
 
     @Override
     public void enterBraceOrEqualInitializer(CPP14Parser.BraceOrEqualInitializerContext ctx) {
-        System.out.println("enterBraceOrEqualInitializer");
+        printWithCounter("enterBraceOrEqualInitializer");
 
     }
 
     @Override
     public void exitBraceOrEqualInitializer(CPP14Parser.BraceOrEqualInitializerContext ctx) {
-        System.out.println("exitBraceOrEqualInitializer");
+        printWithCounter("exitBraceOrEqualInitializer");
 
     }
 
     @Override
     public void enterInitializerClause(CPP14Parser.InitializerClauseContext ctx) {
-        System.out.println("enterInitializerClause");
+        printWithCounter("enterInitializerClause");
 
     }
 
     @Override
     public void exitInitializerClause(CPP14Parser.InitializerClauseContext ctx) {
-        System.out.println("exitInitializerClause");
+        printWithCounter("exitInitializerClause");
 
     }
 
     @Override
     public void enterInitializerList(CPP14Parser.InitializerListContext ctx) {
-        System.out.println("enterInitializerList");
+        printWithCounter("enterInitializerList");
 
     }
 
     @Override
     public void exitInitializerList(CPP14Parser.InitializerListContext ctx) {
-        System.out.println("exitInitializerList");
+        printWithCounter("exitInitializerList");
 
     }
 
     @Override
     public void enterBracedInitList(CPP14Parser.BracedInitListContext ctx) {
-        System.out.println("enterBracedInitList");
+        printWithCounter("enterBracedInitList");
 
     }
 
     @Override
     public void exitBracedInitList(CPP14Parser.BracedInitListContext ctx) {
-        System.out.println("exitBracedInitList");
+        printWithCounter("exitBracedInitList");
 
     }
 
     @Override
     public void enterClassName(CPP14Parser.ClassNameContext ctx) {
-        System.out.println("enterClassName");
+        printWithCounter("enterClassName");
 
     }
 
     @Override
     public void exitClassName(CPP14Parser.ClassNameContext ctx) {
-        System.out.println("exitClassName");
+        printWithCounter("exitClassName");
 
     }
 
     @Override
     public void enterClassSpecifier(CPP14Parser.ClassSpecifierContext ctx) {
-        System.out.println("enterClassSpecifier");
+        printWithCounter("enterClassSpecifier");
 
     }
 
     @Override
     public void exitClassSpecifier(CPP14Parser.ClassSpecifierContext ctx) {
-        System.out.println("exitClassSpecifier");
+        printWithCounter("exitClassSpecifier");
 
     }
 
     @Override
     public void enterClassHead(CPP14Parser.ClassHeadContext ctx) {
-        System.out.println("enterClassHead");
+        printWithCounter("enterClassHead");
 
     }
 
     @Override
     public void exitClassHead(CPP14Parser.ClassHeadContext ctx) {
-        System.out.println("exitClassHead");
+        printWithCounter("exitClassHead");
 
     }
 
     @Override
     public void enterClassHeadName(CPP14Parser.ClassHeadNameContext ctx) {
-        System.out.println("enterClassHeadName");
+        printWithCounter("enterClassHeadName");
 
     }
 
     @Override
     public void exitClassHeadName(CPP14Parser.ClassHeadNameContext ctx) {
-        System.out.println("exitClassHeadName");
+        printWithCounter("exitClassHeadName");
 
     }
 
     @Override
     public void enterClassVirtSpecifier(CPP14Parser.ClassVirtSpecifierContext ctx) {
-        System.out.println("enterClassVirtSpecifier");
+        printWithCounter("enterClassVirtSpecifier");
 
     }
 
     @Override
     public void exitClassVirtSpecifier(CPP14Parser.ClassVirtSpecifierContext ctx) {
-        System.out.println("exitClassVirtSpecifier");
+        printWithCounter("exitClassVirtSpecifier");
 
     }
 
     @Override
     public void enterClassKey(CPP14Parser.ClassKeyContext ctx) {
-        System.out.println("enterClassKey");
+        printWithCounter("enterClassKey");
 
     }
 
     @Override
     public void exitClassKey(CPP14Parser.ClassKeyContext ctx) {
-        System.out.println("exitClassKey");
+        printWithCounter("exitClassKey");
 
     }
 
     @Override
     public void enterMemberSpecification(CPP14Parser.MemberSpecificationContext ctx) {
-        System.out.println("enterMemberSpecification");
+        printWithCounter("enterMemberSpecification");
 
     }
 
     @Override
     public void exitMemberSpecification(CPP14Parser.MemberSpecificationContext ctx) {
-        System.out.println("exitMemberSpecification");
+        printWithCounter("exitMemberSpecification");
 
     }
 
     @Override
     public void enterMemberdeclaration(CPP14Parser.MemberdeclarationContext ctx) {
-        System.out.println("enterMemberdeclaration");
+        printWithCounter("enterMemberdeclaration");
 
     }
 
     @Override
     public void exitMemberdeclaration(CPP14Parser.MemberdeclarationContext ctx) {
-        System.out.println("exitMemberdeclaration");
+        printWithCounter("exitMemberdeclaration");
 
     }
 
     @Override
     public void enterMemberDeclaratorList(CPP14Parser.MemberDeclaratorListContext ctx) {
-        System.out.println("enterMemberDeclaratorList");
+        printWithCounter("enterMemberDeclaratorList");
 
     }
 
     @Override
     public void exitMemberDeclaratorList(CPP14Parser.MemberDeclaratorListContext ctx) {
-        System.out.println("exitMemberDeclaratorList");
+        printWithCounter("exitMemberDeclaratorList");
 
     }
 
     @Override
     public void enterMemberDeclarator(CPP14Parser.MemberDeclaratorContext ctx) {
-        System.out.println("enterMemberDeclarator");
+        printWithCounter("enterMemberDeclarator");
 
     }
 
     @Override
     public void exitMemberDeclarator(CPP14Parser.MemberDeclaratorContext ctx) {
-        System.out.println("exitMemberDeclarator");
+        printWithCounter("exitMemberDeclarator");
 
     }
 
     @Override
     public void enterVirtualSpecifierSeq(CPP14Parser.VirtualSpecifierSeqContext ctx) {
-        System.out.println("enterVirtualSpecifierSeq");
+        printWithCounter("enterVirtualSpecifierSeq");
 
     }
 
     @Override
     public void exitVirtualSpecifierSeq(CPP14Parser.VirtualSpecifierSeqContext ctx) {
-        System.out.println("exitVirtualSpecifierSeq");
+        printWithCounter("exitVirtualSpecifierSeq");
 
     }
 
     @Override
     public void enterVirtualSpecifier(CPP14Parser.VirtualSpecifierContext ctx) {
-        System.out.println("enterVirtualSpecifier");
+        printWithCounter("enterVirtualSpecifier");
 
     }
 
     @Override
     public void exitVirtualSpecifier(CPP14Parser.VirtualSpecifierContext ctx) {
-        System.out.println("exitVirtualSpecifier");
+        printWithCounter("exitVirtualSpecifier");
 
     }
 
     @Override
     public void enterPureSpecifier(CPP14Parser.PureSpecifierContext ctx) {
-        System.out.println("enterPureSpecifier");
+        printWithCounter("enterPureSpecifier");
 
     }
 
     @Override
     public void exitPureSpecifier(CPP14Parser.PureSpecifierContext ctx) {
-        System.out.println("exitPureSpecifier");
+        printWithCounter("exitPureSpecifier");
 
     }
 
     @Override
     public void enterBaseClause(CPP14Parser.BaseClauseContext ctx) {
-        System.out.println("enterBaseClause");
+        printWithCounter("enterBaseClause");
 
     }
 
     @Override
     public void exitBaseClause(CPP14Parser.BaseClauseContext ctx) {
-        System.out.println("exitBaseClause");
+        printWithCounter("exitBaseClause");
 
     }
 
     @Override
     public void enterBaseSpecifierList(CPP14Parser.BaseSpecifierListContext ctx) {
-        System.out.println("enterBaseSpecifierList");
+        printWithCounter("enterBaseSpecifierList");
 
     }
 
     @Override
     public void exitBaseSpecifierList(CPP14Parser.BaseSpecifierListContext ctx) {
-        System.out.println("exitBaseSpecifierList");
+        printWithCounter("exitBaseSpecifierList");
 
     }
 
     @Override
     public void enterBaseSpecifier(CPP14Parser.BaseSpecifierContext ctx) {
-        System.out.println("enterBaseSpecifier");
+        printWithCounter("enterBaseSpecifier");
 
     }
 
     @Override
     public void exitBaseSpecifier(CPP14Parser.BaseSpecifierContext ctx) {
-        System.out.println("exitBaseSpecifier");
+        printWithCounter("exitBaseSpecifier");
 
     }
 
     @Override
     public void enterClassOrDeclType(CPP14Parser.ClassOrDeclTypeContext ctx) {
-        System.out.println("enterClassOrDeclType");
+        printWithCounter("enterClassOrDeclType");
 
     }
 
     @Override
     public void exitClassOrDeclType(CPP14Parser.ClassOrDeclTypeContext ctx) {
-        System.out.println("exitClassOrDeclType");
+        printWithCounter("exitClassOrDeclType");
 
     }
 
     @Override
     public void enterBaseTypeSpecifier(CPP14Parser.BaseTypeSpecifierContext ctx) {
-        System.out.println("enterBaseTypeSpecifier");
+        printWithCounter("enterBaseTypeSpecifier");
 
     }
 
     @Override
     public void exitBaseTypeSpecifier(CPP14Parser.BaseTypeSpecifierContext ctx) {
-        System.out.println("exitBaseTypeSpecifier");
+        printWithCounter("exitBaseTypeSpecifier");
 
     }
 
     @Override
     public void enterAccessSpecifier(CPP14Parser.AccessSpecifierContext ctx) {
-        System.out.println("enterAccessSpecifier");
+        printWithCounter("enterAccessSpecifier");
 
     }
 
     @Override
     public void exitAccessSpecifier(CPP14Parser.AccessSpecifierContext ctx) {
-        System.out.println("exitAccessSpecifier");
+        printWithCounter("exitAccessSpecifier");
 
     }
 
     @Override
     public void enterConversionFunctionId(CPP14Parser.ConversionFunctionIdContext ctx) {
-        System.out.println("enterConversionFunctionId");
+        printWithCounter("enterConversionFunctionId");
 
     }
 
     @Override
     public void exitConversionFunctionId(CPP14Parser.ConversionFunctionIdContext ctx) {
-        System.out.println("exitConversionFunctionId");
+        printWithCounter("exitConversionFunctionId");
 
     }
 
     @Override
     public void enterConversionTypeId(CPP14Parser.ConversionTypeIdContext ctx) {
-        System.out.println("enterConversionTypeId");
+        printWithCounter("enterConversionTypeId");
 
     }
 
     @Override
     public void exitConversionTypeId(CPP14Parser.ConversionTypeIdContext ctx) {
-        System.out.println("exitConversionTypeId");
+        printWithCounter("exitConversionTypeId");
 
     }
 
     @Override
     public void enterConversionDeclarator(CPP14Parser.ConversionDeclaratorContext ctx) {
-        System.out.println("enterConversionDeclarator");
+        printWithCounter("enterConversionDeclarator");
 
     }
 
     @Override
     public void exitConversionDeclarator(CPP14Parser.ConversionDeclaratorContext ctx) {
-        System.out.println("exitConversionDeclarator");
+        printWithCounter("exitConversionDeclarator");
 
     }
 
     @Override
     public void enterConstructorInitializer(CPP14Parser.ConstructorInitializerContext ctx) {
-        System.out.println("enterConstructorInitializer");
+        printWithCounter("enterConstructorInitializer");
 
     }
 
     @Override
     public void exitConstructorInitializer(CPP14Parser.ConstructorInitializerContext ctx) {
-        System.out.println("exitConstructorInitializer");
+        printWithCounter("exitConstructorInitializer");
 
     }
 
     @Override
     public void enterMemInitializerList(CPP14Parser.MemInitializerListContext ctx) {
-        System.out.println("enterMemInitializerList");
+        printWithCounter("enterMemInitializerList");
 
     }
 
     @Override
     public void exitMemInitializerList(CPP14Parser.MemInitializerListContext ctx) {
-        System.out.println("exitMemInitializerList");
+        printWithCounter("exitMemInitializerList");
 
     }
 
     @Override
     public void enterMemInitializer(CPP14Parser.MemInitializerContext ctx) {
-        System.out.println("enterMemInitializer");
+        printWithCounter("enterMemInitializer");
 
     }
 
     @Override
     public void exitMemInitializer(CPP14Parser.MemInitializerContext ctx) {
-        System.out.println("exitMemInitializer");
+        printWithCounter("exitMemInitializer");
 
     }
 
     @Override
     public void enterMeminitializerid(CPP14Parser.MeminitializeridContext ctx) {
-        System.out.println("enterMeminitializerid");
+        printWithCounter("enterMeminitializerid");
 
     }
 
     @Override
     public void exitMeminitializerid(CPP14Parser.MeminitializeridContext ctx) {
-        System.out.println("exitMeminitializerid");
+        printWithCounter("exitMeminitializerid");
 
     }
 
     @Override
     public void enterOperatorFunctionId(CPP14Parser.OperatorFunctionIdContext ctx) {
-        System.out.println("enterOperatorFunctionId");
+        printWithCounter("enterOperatorFunctionId");
 
     }
 
     @Override
     public void exitOperatorFunctionId(CPP14Parser.OperatorFunctionIdContext ctx) {
-        System.out.println("exitOperatorFunctionId");
+        printWithCounter("exitOperatorFunctionId");
 
     }
 
     @Override
     public void enterLiteralOperatorId(CPP14Parser.LiteralOperatorIdContext ctx) {
-        System.out.println("enterLiteralOperatorId");
+        printWithCounter("enterLiteralOperatorId");
 
     }
 
     @Override
     public void exitLiteralOperatorId(CPP14Parser.LiteralOperatorIdContext ctx) {
-        System.out.println("exitLiteralOperatorId");
+        printWithCounter("exitLiteralOperatorId");
 
     }
 
     @Override
     public void enterTemplateDeclaration(CPP14Parser.TemplateDeclarationContext ctx) {
-        System.out.println("enterTemplateDeclaration");
+        printWithCounter("enterTemplateDeclaration");
 
     }
 
     @Override
     public void exitTemplateDeclaration(CPP14Parser.TemplateDeclarationContext ctx) {
-        System.out.println("exitTemplateDeclaration");
+        printWithCounter("exitTemplateDeclaration");
 
     }
 
     @Override
     public void enterTemplateparameterList(CPP14Parser.TemplateparameterListContext ctx) {
-        System.out.println("enterTemplateparameterList");
+        printWithCounter("enterTemplateparameterList");
 
     }
 
     @Override
     public void exitTemplateparameterList(CPP14Parser.TemplateparameterListContext ctx) {
-        System.out.println("exitTemplateparameterList");
+        printWithCounter("exitTemplateparameterList");
 
     }
 
     @Override
     public void enterTemplateParameter(CPP14Parser.TemplateParameterContext ctx) {
-        System.out.println("enterTemplateParameter");
+        printWithCounter("enterTemplateParameter");
 
     }
 
     @Override
     public void exitTemplateParameter(CPP14Parser.TemplateParameterContext ctx) {
-        System.out.println("exitTemplateParameter");
+        printWithCounter("exitTemplateParameter");
 
     }
 
     @Override
     public void enterTypeParameter(CPP14Parser.TypeParameterContext ctx) {
-        System.out.println("enterTypeParameter");
+        printWithCounter("enterTypeParameter");
 
     }
 
     @Override
     public void exitTypeParameter(CPP14Parser.TypeParameterContext ctx) {
-        System.out.println("exitTypeParameter");
+        printWithCounter("exitTypeParameter");
 
     }
 
     @Override
     public void enterSimpleTemplateId(CPP14Parser.SimpleTemplateIdContext ctx) {
-        System.out.println("enterSimpleTemplateId");
+        printWithCounter("enterSimpleTemplateId");
 
     }
 
     @Override
     public void exitSimpleTemplateId(CPP14Parser.SimpleTemplateIdContext ctx) {
-        System.out.println("exitSimpleTemplateId");
+        printWithCounter("exitSimpleTemplateId");
 
     }
 
     @Override
     public void enterTemplateId(CPP14Parser.TemplateIdContext ctx) {
-        System.out.println("enterTemplateId");
+        printWithCounter("enterTemplateId");
 
     }
 
     @Override
     public void exitTemplateId(CPP14Parser.TemplateIdContext ctx) {
-        System.out.println("exitTemplateId");
+        printWithCounter("exitTemplateId");
 
     }
 
     @Override
     public void enterTemplateName(CPP14Parser.TemplateNameContext ctx) {
-        System.out.println("enterTemplateName");
+        printWithCounter("enterTemplateName");
 
     }
 
     @Override
     public void exitTemplateName(CPP14Parser.TemplateNameContext ctx) {
-        System.out.println("exitTemplateName");
+        printWithCounter("exitTemplateName");
 
     }
 
     @Override
     public void enterTemplateArgumentList(CPP14Parser.TemplateArgumentListContext ctx) {
-        System.out.println("enterTemplateArgumentList");
+        printWithCounter("enterTemplateArgumentList");
 
     }
 
     @Override
     public void exitTemplateArgumentList(CPP14Parser.TemplateArgumentListContext ctx) {
-        System.out.println("exitTemplateArgumentList");
+        printWithCounter("exitTemplateArgumentList");
 
     }
 
     @Override
     public void enterTemplateArgument(CPP14Parser.TemplateArgumentContext ctx) {
-        System.out.println("enterTemplateArgument");
+        printWithCounter("enterTemplateArgument");
 
     }
 
     @Override
     public void exitTemplateArgument(CPP14Parser.TemplateArgumentContext ctx) {
-        System.out.println("exitTemplateArgument");
+        printWithCounter("exitTemplateArgument");
 
     }
 
     @Override
     public void enterTypeNameSpecifier(CPP14Parser.TypeNameSpecifierContext ctx) {
-        System.out.println("enterTypeNameSpecifier");
+        printWithCounter("enterTypeNameSpecifier");
 
     }
 
     @Override
     public void exitTypeNameSpecifier(CPP14Parser.TypeNameSpecifierContext ctx) {
-        System.out.println("exitTypeNameSpecifier");
+        printWithCounter("exitTypeNameSpecifier");
 
     }
 
     @Override
     public void enterExplicitInstantiation(CPP14Parser.ExplicitInstantiationContext ctx) {
-        System.out.println("enterExplicitInstantiation");
+        printWithCounter("enterExplicitInstantiation");
 
     }
 
     @Override
     public void exitExplicitInstantiation(CPP14Parser.ExplicitInstantiationContext ctx) {
-        System.out.println("exitExplicitInstantiation");
+        printWithCounter("exitExplicitInstantiation");
 
     }
 
     @Override
     public void enterExplicitSpecialization(CPP14Parser.ExplicitSpecializationContext ctx) {
-        System.out.println("enterExplicitSpecialization");
+        printWithCounter("enterExplicitSpecialization");
 
     }
 
     @Override
     public void exitExplicitSpecialization(CPP14Parser.ExplicitSpecializationContext ctx) {
-        System.out.println("exitExplicitSpecialization");
+        printWithCounter("exitExplicitSpecialization");
 
     }
 
     @Override
     public void enterTryBlock(CPP14Parser.TryBlockContext ctx) {
-        System.out.println("enterTryBlock");
+        printWithCounter("enterTryBlock");
 
     }
 
     @Override
     public void exitTryBlock(CPP14Parser.TryBlockContext ctx) {
-        System.out.println("exitTryBlock");
+        printWithCounter("exitTryBlock");
 
     }
 
     @Override
     public void enterFunctionTryBlock(CPP14Parser.FunctionTryBlockContext ctx) {
-        System.out.println("enterFunctionTryBlock");
+        printWithCounter("enterFunctionTryBlock");
 
     }
 
     @Override
     public void exitFunctionTryBlock(CPP14Parser.FunctionTryBlockContext ctx) {
-        System.out.println("exitFunctionTryBlock");
+        printWithCounter("exitFunctionTryBlock");
 
     }
 
     @Override
     public void enterHandlerSeq(CPP14Parser.HandlerSeqContext ctx) {
-        System.out.println("enterHandlerSeq");
+        printWithCounter("enterHandlerSeq");
 
     }
 
     @Override
     public void exitHandlerSeq(CPP14Parser.HandlerSeqContext ctx) {
-        System.out.println("exitHandlerSeq");
+        printWithCounter("exitHandlerSeq");
 
     }
 
     @Override
     public void enterHandler(CPP14Parser.HandlerContext ctx) {
-        System.out.println("enterHandler");
+        printWithCounter("enterHandler");
 
     }
 
     @Override
     public void exitHandler(CPP14Parser.HandlerContext ctx) {
-        System.out.println("exitHandler");
+        printWithCounter("exitHandler");
 
     }
 
     @Override
     public void enterExceptionDeclaration(CPP14Parser.ExceptionDeclarationContext ctx) {
-        System.out.println("enterExceptionDeclaration");
+        printWithCounter("enterExceptionDeclaration");
 
     }
 
     @Override
     public void exitExceptionDeclaration(CPP14Parser.ExceptionDeclarationContext ctx) {
-        System.out.println("exitExceptionDeclaration");
+        printWithCounter("exitExceptionDeclaration");
 
     }
 
     @Override
     public void enterThrowExpression(CPP14Parser.ThrowExpressionContext ctx) {
-        System.out.println("enterThrowExpression");
+        printWithCounter("enterThrowExpression");
 
     }
 
     @Override
     public void exitThrowExpression(CPP14Parser.ThrowExpressionContext ctx) {
-        System.out.println("exitThrowExpression");
+        printWithCounter("exitThrowExpression");
 
     }
 
     @Override
     public void enterExceptionSpecification(CPP14Parser.ExceptionSpecificationContext ctx) {
-        System.out.println("enterExceptionSpecification");
+        printWithCounter("enterExceptionSpecification");
 
     }
 
     @Override
     public void exitExceptionSpecification(CPP14Parser.ExceptionSpecificationContext ctx) {
-        System.out.println("exitExceptionSpecification");
+        printWithCounter("exitExceptionSpecification");
 
     }
 
     @Override
     public void enterDynamicExceptionSpecification(CPP14Parser.DynamicExceptionSpecificationContext ctx) {
-        System.out.println("enterDynamicExceptionSpecification");
+        printWithCounter("enterDynamicExceptionSpecification");
 
     }
 
     @Override
     public void exitDynamicExceptionSpecification(CPP14Parser.DynamicExceptionSpecificationContext ctx) {
-        System.out.println("exitDynamicExceptionSpecification");
+        printWithCounter("exitDynamicExceptionSpecification");
 
     }
 
     @Override
     public void enterTypeIdList(CPP14Parser.TypeIdListContext ctx) {
-        System.out.println("enterTypeIdList");
+        printWithCounter("enterTypeIdList");
 
     }
 
     @Override
     public void exitTypeIdList(CPP14Parser.TypeIdListContext ctx) {
-        System.out.println("exitTypeIdList");
+        printWithCounter("exitTypeIdList");
 
     }
 
     @Override
     public void enterNoeExceptSpecification(CPP14Parser.NoeExceptSpecificationContext ctx) {
-        System.out.println("enterNoeExceptSpecification");
+        printWithCounter("enterNoeExceptSpecification");
 
     }
 
     @Override
     public void exitNoeExceptSpecification(CPP14Parser.NoeExceptSpecificationContext ctx) {
-        System.out.println("exitNoeExceptSpecification");
+        printWithCounter("exitNoeExceptSpecification");
 
     }
 
     @Override
     public void enterTheOperator(CPP14Parser.TheOperatorContext ctx) {
-        System.out.println("enterTheOperator");
+        printWithCounter("enterTheOperator");
 
     }
 
     @Override
     public void exitTheOperator(CPP14Parser.TheOperatorContext ctx) {
-        System.out.println("exitTheOperator");
+        printWithCounter("exitTheOperator");
 
     }
 
     @Override
     public void enterLiteral(CPP14Parser.LiteralContext ctx) {
-        System.out.println("enterLiteral");
+        printWithCounter("enterLiteral");
 
     }
 
     @Override
     public void exitLiteral(CPP14Parser.LiteralContext ctx) {
-        System.out.println("exitLiteral");
+        printWithCounter("exitLiteral");
 
     }
 
     @Override
     public void visitTerminal(TerminalNode terminalNode) {
-        System.out.println("visitTerminal " + terminalNode.getSymbol().getText());
+        printWithCounter("visitTerminal " + terminalNode.getSymbol().getText());
 
     }
 
     @Override
     public void visitErrorNode(ErrorNode errorNode) {
-        System.out.println("visitErrorNode");
+        printWithCounter("visitErrorNode");
 
     }
 }