=====================Reduction starts.======================

The initial program size is 22
------------------------------------------------------------


=Fixpoint iteration 1. Reducer: perses_node_priority_with_dfs_delta

The spar-tree is the following.
translationUnit {id=1}
|___(+) {id=2,slot_type=kleene_plus__translationUnit_3}
    |___functionDefinition {id=4,slot_type=[aux_rule__translationUnit_2,functionDefinition]}
        |___(?) {id=5,slot_type=optional__functionDefinition_2}
        |   |___(+) {id=126,slot_type=declarationSpecifiers}
        |       |___Token:int {id=130,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=117,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=125,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=119,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=121,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=122,slot_type=LeftParen}
        |           |___Token:) {id=124,slot_type=RightParen}
        |___compoundStatement {id=7,slot_type=compoundStatement}
            |___Token:{ {id=8,slot_type=LeftBrace}
            |___(?) {id=9,slot_type=optional__compoundStatement_1}
            |   |___(+) {id=12,slot_type=[blockItemList,kleene_plus__blockItemList_3]}
            |       |___aux_rule__declaration_3 {id=82,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=83,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=116,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=84,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=87,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:var {id=112,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=89,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=90,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=91,slot_type=Assign}
            |       |   |               |___Token:99 {id=109,slot_type=[initializer,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Constant]}
            |       |   |___Token:; {id=85,slot_type=Semi}
            |       |___aux_rule__statement_3 {id=42,slot_type=[aux_rule__blockItemList_2,statement,aux_rule__statement_3]}
            |       |   |___Token:if {id=43,slot_type=If}
            |       |   |___Token:( {id=44,slot_type=LeftParen}
            |       |   |___equalityExpression {id=58,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression]}
            |       |   |   |___Token:var {id=80,slot_type=[relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |       |   |   |___(*) {id=60,slot_type=kleene_star__equalityExpression_1}
            |       |   |       |___aux_rule__equalityExpression_2 {id=61,slot_type=aux_rule__equalityExpression_2}
            |       |   |           |___Token:== {id=72,slot_type=[altnt_block__equalityExpression_3,Equal]}
            |       |   |           |___Token:100 {id=71,slot_type=[relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Constant]}
            |       |   |___Token:) {id=46,slot_type=RightParen}
            |       |   |___compoundStatement {id=48,slot_type=[statement,compoundStatement]}
            |       |       |___Token:{ {id=49,slot_type=LeftBrace}
            |       |       |___Token:} {id=50,slot_type=RightBrace}
            |       |___jumpStatement {id=17,slot_type=[aux_rule__blockItemList_2,statement,jumpStatement]}
            |           |___aux_rule__jumpStatement_4 {id=20,slot_type=[altnt_block__jumpStatement_2,aux_rule__jumpStatement_4]}
            |           |   |___Token:return {id=21,slot_type=Return}
            |           |   |___(?) {id=22,slot_type=optional__postfixExpression_1}
            |           |       |___Token:var {id=40,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |           |___Token:; {id=19,slot_type=Semi}
            |___Token:} {id=10,slot_type=RightBrace}
------------------------------------------------------------


==================Reducing node 2, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 2
------------------------------------------------------------


==================Reducing node 4, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    ;
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    ;
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int var = 99;
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 4
------------------------------------------------------------


==================Reducing node 7, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main()
                      {}
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 7
------------------------------------------------------------


==================Reducing node 9, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__compoundStatement_1]dd@1
    int main() {
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 9
------------------------------------------------------------


=================Reducing node 12, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]can be epsilon
    int main() {
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]remove whole except first
    int main() {
      int var = 99;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main() {
      int var = 99;
      if (var == 100) {}
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    int main() {
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main() {
      int var = 99;
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main() {
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 12
------------------------------------------------------------


=================Reducing node 42, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      int var = 99;
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
      int var = 99;
                      {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 42
------------------------------------------------------------


=================Reducing node 82, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
                  ;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 82
------------------------------------------------------------


=================Reducing node 117, size=22=================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main   {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 117
------------------------------------------------------------


=================Reducing node 84, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    int main() {
      int         ;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 84
------------------------------------------------------------


=================Reducing node 87, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      int         ;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
      int var     ;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 87
------------------------------------------------------------


=================Reducing node 58, size=22==================

The current best program is the following

    int main() {
      int var = 99;
      if (var == 100) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: pass=============

// edit action set type: [regular node]compatible replacement
    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Test script execution is cancelled.=============

It took less than 1 second to cancel the task.

    int main() {
      int var = 99;
      if (       100) {}
      return var;
    }
------------------------------------------------------------


===========TestScriptExecutionCacheEntryEviction============

0 entries are removed: 0 --> 0.
------------------------------------------------------------


===========Node edit action set cache is cleared.===========

    size before clearance = 0
------------------------------------------------------------


===================Node reduction is done===================

Succeeded to reduce node 58 from 22 to 20
------------------------------------------------------------


=================Reducing node 17, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      int var = 99;
      if (var       ) {}
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
      int var = 99;
      if (var       ) {}
                ;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 17
------------------------------------------------------------


=================Reducing node 119, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:kleene_star__directDeclarator_7]dd@1
    int main   {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 119
------------------------------------------------------------


=================Reducing node 121, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main   {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 121
------------------------------------------------------------


=================Reducing node 89, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    int main() {
      int var     ;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 89
------------------------------------------------------------


=================Reducing node 90, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      int var     ;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 90
------------------------------------------------------------


=================Reducing node 48, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 48
------------------------------------------------------------


=================Reducing node 20, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
      int var = 99;
      if (var       ) {}
      return    ;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 20
------------------------------------------------------------


=================Reducing node 125, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 125
------------------------------------------------------------


=================Reducing node 124, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 124
------------------------------------------------------------


=================Reducing node 122, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 122
------------------------------------------------------------


=================Reducing node 112, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 112
------------------------------------------------------------


=================Reducing node 109, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 109
------------------------------------------------------------


=================Reducing node 91, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 91
------------------------------------------------------------


=================Reducing node 85, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 85
------------------------------------------------------------


=================Reducing node 83, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 83
------------------------------------------------------------


=================Reducing node 116, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 116
------------------------------------------------------------


=================Reducing node 80, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 80
------------------------------------------------------------


=================Reducing node 50, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 50
------------------------------------------------------------


=================Reducing node 49, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 49
------------------------------------------------------------


=================Reducing node 46, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 46
------------------------------------------------------------


=================Reducing node 44, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 44
------------------------------------------------------------


=================Reducing node 43, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 43
------------------------------------------------------------


=================Reducing node 22, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main() {
      int var = 99;
      if (var       ) {}
      return    ;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 22
------------------------------------------------------------


=================Reducing node 40, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 40
------------------------------------------------------------


=================Reducing node 21, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 21
------------------------------------------------------------


=================Reducing node 19, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 19
------------------------------------------------------------


=================Reducing node 10, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 10
------------------------------------------------------------


==================Reducing node 8, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 8
------------------------------------------------------------


==================Reducing node 5, size=20==================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__functionDefinition_2]dd@1
    main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 5
------------------------------------------------------------


=================Reducing node 126, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:declarationSpecifiers]can be epsilon
    main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 126
------------------------------------------------------------


=================Reducing node 130, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 130
------------------------------------------------------------


=Fixpoint iteration 2. Reducer: perses_node_priority_with_dfs_delta

The spar-tree is the following.
translationUnit {id=131}
|___(+) {id=132,slot_type=kleene_plus__translationUnit_3}
    |___functionDefinition {id=134,slot_type=[aux_rule__translationUnit_2,functionDefinition]}
        |___(?) {id=135,slot_type=optional__functionDefinition_2}
        |   |___(+) {id=243,slot_type=declarationSpecifiers}
        |       |___Token:int {id=247,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=234,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=242,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=236,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=238,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=239,slot_type=LeftParen}
        |           |___Token:) {id=241,slot_type=RightParen}
        |___compoundStatement {id=137,slot_type=compoundStatement}
            |___Token:{ {id=138,slot_type=LeftBrace}
            |___(?) {id=139,slot_type=optional__compoundStatement_1}
            |   |___(+) {id=142,slot_type=[blockItemList,kleene_plus__blockItemList_3]}
            |       |___aux_rule__declaration_3 {id=199,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=200,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=233,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=201,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=204,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:var {id=229,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=206,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=207,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=208,slot_type=Assign}
            |       |   |               |___Token:99 {id=226,slot_type=[initializer,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Constant]}
            |       |   |___Token:; {id=202,slot_type=Semi}
            |       |___aux_rule__statement_3 {id=172,slot_type=[aux_rule__blockItemList_2,statement,aux_rule__statement_3]}
            |       |   |___Token:if {id=173,slot_type=If}
            |       |   |___Token:( {id=174,slot_type=LeftParen}
            |       |   |___Token:var {id=197,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |       |   |___Token:) {id=176,slot_type=RightParen}
            |       |   |___compoundStatement {id=178,slot_type=[statement,compoundStatement]}
            |       |       |___Token:{ {id=179,slot_type=LeftBrace}
            |       |       |___Token:} {id=180,slot_type=RightBrace}
            |       |___jumpStatement {id=147,slot_type=[aux_rule__blockItemList_2,statement,jumpStatement]}
            |           |___aux_rule__jumpStatement_4 {id=150,slot_type=[altnt_block__jumpStatement_2,aux_rule__jumpStatement_4]}
            |           |   |___Token:return {id=151,slot_type=Return}
            |           |   |___(?) {id=152,slot_type=optional__postfixExpression_1}
            |           |       |___Token:var {id=170,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |           |___Token:; {id=149,slot_type=Semi}
            |___Token:} {id=140,slot_type=RightBrace}
------------------------------------------------------------


=================Reducing node 132, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 132
------------------------------------------------------------


=================Reducing node 134, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    ;
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    ;
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int var = 99;
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 134
------------------------------------------------------------


=================Reducing node 137, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main()
                      {}
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 137
------------------------------------------------------------


=================Reducing node 139, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__compoundStatement_1]dd@1
    int main() {
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 139
------------------------------------------------------------


=================Reducing node 142, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]can be epsilon
    int main() {
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]remove whole except first
    int main() {
      int var = 99;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main() {
      int var = 99;
      if (var       ) {}
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    int main() {
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main() {
      int var = 99;
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main() {
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 142
------------------------------------------------------------


=================Reducing node 172, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      int var = 99;
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
      int var = 99;
                      {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 172
------------------------------------------------------------


=================Reducing node 199, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
                  ;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 199
------------------------------------------------------------


=================Reducing node 234, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main   {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 234
------------------------------------------------------------


=================Reducing node 201, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    int main() {
      int         ;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 201
------------------------------------------------------------


=================Reducing node 204, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      int         ;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
      int var     ;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 204
------------------------------------------------------------


=================Reducing node 147, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      int var = 99;
      if (var       ) {}
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
      int var = 99;
      if (var       ) {}
                ;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 147
------------------------------------------------------------


=================Reducing node 236, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:kleene_star__directDeclarator_7]dd@1
    int main   {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 236
------------------------------------------------------------


=================Reducing node 238, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main   {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 238
------------------------------------------------------------


=================Reducing node 206, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    int main() {
      int var     ;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 206
------------------------------------------------------------


=================Reducing node 207, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular_node]can be epsilon
    int main() {
      int var     ;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 207
------------------------------------------------------------


=================Reducing node 178, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 178
------------------------------------------------------------


=================Reducing node 150, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [regular node]compatible replacement
    int main() {
      int var = 99;
      if (var       ) {}
      return    ;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 150
------------------------------------------------------------


=================Reducing node 242, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 242
------------------------------------------------------------


=================Reducing node 241, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 241
------------------------------------------------------------


=================Reducing node 239, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 239
------------------------------------------------------------


=================Reducing node 229, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 229
------------------------------------------------------------


=================Reducing node 226, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 226
------------------------------------------------------------


=================Reducing node 208, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 208
------------------------------------------------------------


=================Reducing node 202, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 202
------------------------------------------------------------


=================Reducing node 200, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 200
------------------------------------------------------------


=================Reducing node 233, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 233
------------------------------------------------------------


=================Reducing node 197, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 197
------------------------------------------------------------


=================Reducing node 180, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 180
------------------------------------------------------------


=================Reducing node 179, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 179
------------------------------------------------------------


=================Reducing node 176, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 176
------------------------------------------------------------


=================Reducing node 174, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 174
------------------------------------------------------------


=================Reducing node 173, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 173
------------------------------------------------------------


=================Reducing node 152, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main() {
      int var = 99;
      if (var       ) {}
      return    ;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 152
------------------------------------------------------------


=================Reducing node 170, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 170
------------------------------------------------------------


=================Reducing node 151, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 151
------------------------------------------------------------


=================Reducing node 149, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 149
------------------------------------------------------------


=================Reducing node 140, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 140
------------------------------------------------------------


=================Reducing node 138, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 138
------------------------------------------------------------


=================Reducing node 135, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_star:optional__functionDefinition_2]dd@1
    main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 135
------------------------------------------------------------


=================Reducing node 243, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


============Testing the following program: fail=============

// edit action set type: [kleene_plus:declarationSpecifiers]can be epsilon
    main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 243
------------------------------------------------------------


=================Reducing node 247, size=20=================

The current best program is the following

    int main() {
      int var = 99;
      if (var       ) {}
      return var;
    }
------------------------------------------------------------


===================Node reduction is done===================

Failed to reduce node 247
------------------------------------------------------------


#test success = 1
#test failure = 58
#test result cache hits = 0
#test execution cancelled = 1
#node edit action set cache hits = 0
#external test execution cache hits = 0
