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

The initial program size is 38
------------------------------------------------------------


=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}
    |___Token:#include <stdio.h> {id=279,slot_type=[aux_rule__translationUnit_2,IncludeDirective]}
    |___functionDefinition {id=5,slot_type=[aux_rule__translationUnit_2,functionDefinition]}
        |___(?) {id=6,slot_type=optional__functionDefinition_2}
        |   |___(+) {id=274,slot_type=declarationSpecifiers}
        |       |___Token:int {id=278,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=256,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=273,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=258,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=260,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=261,slot_type=LeftParen}
        |           |___(+) {id=267,slot_type=[altnt_block__directDeclarator_11,parameterTypeList,parameterList,parameterDeclaration,declarationSpecifiers]}
        |           |   |___Token:void {id=272,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Void]}
        |           |___Token:) {id=263,slot_type=RightParen}
        |___compoundStatement {id=8,slot_type=compoundStatement}
            |___Token:{ {id=9,slot_type=LeftBrace}
            |___(?) {id=10,slot_type=optional__compoundStatement_1}
            |   |___(+) {id=13,slot_type=[blockItemList,kleene_plus__blockItemList_3]}
            |       |___aux_rule__declaration_3 {id=221,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=222,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=255,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=223,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=226,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:a {id=251,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=228,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=229,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=230,slot_type=Assign}
            |       |   |               |___Token:1 {id=248,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=224,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=185,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=186,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=219,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=187,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=190,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:b {id=215,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=192,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=193,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=194,slot_type=Assign}
            |       |   |               |___Token:2 {id=212,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=188,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=149,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=150,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=183,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=151,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=154,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:c {id=179,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=156,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=157,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=158,slot_type=Assign}
            |       |   |               |___Token:3 {id=176,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=152,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=113,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=114,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=147,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=115,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=118,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:d {id=143,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=120,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=121,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=122,slot_type=Assign}
            |       |   |               |___Token:4 {id=140,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=116,slot_type=Semi}
            |       |___expressionStatement {id=46,slot_type=[aux_rule__blockItemList_2,statement,expressionStatement]}
            |       |   |___(?) {id=47,slot_type=optional__postfixExpression_1}
            |       |   |   |___postfixExpression {id=64,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression]}
            |       |   |       |___Token:printf {id=111,slot_type=[aux_rule__postfixExpression_4,Identifier]}
            |       |   |       |___(*) {id=66,slot_type=kleene_star__postfixExpression_2}
            |       |   |           |___aux_rule__postfixExpression_11 {id=68,slot_type=[aux_rule__postfixExpression_3,aux_rule__postfixExpression_11]}
            |       |   |               |___Token:( {id=69,slot_type=LeftParen}
            |       |   |               |___(?) {id=70,slot_type=optional__postfixExpression_1}
            |       |   |               |   |___expression {id=72,slot_type=expression}
            |       |   |               |       |___(+) {id=109,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,kleene_plus__primaryExpression_1]}
            |       |   |               |       |   |___Token:"%d" {id=110,slot_type=StringLiteral}
            |       |   |               |       |___(*) {id=74,slot_type=kleene_star__expression_1}
            |       |   |               |           |___aux_rule__expression_2 {id=75,slot_type=aux_rule__expression_2}
            |       |   |               |               |___Token:, {id=76,slot_type=Comma}
            |       |   |               |               |___Token:a {id=93,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |       |   |               |___Token:) {id=71,slot_type=RightParen}
            |       |   |___Token:; {id=48,slot_type=Semi}
            |       |___jumpStatement {id=21,slot_type=[aux_rule__blockItemList_2,statement,jumpStatement]}
            |           |___aux_rule__jumpStatement_4 {id=24,slot_type=[altnt_block__jumpStatement_2,aux_rule__jumpStatement_4]}
            |           |   |___Token:return {id=25,slot_type=Return}
            |           |   |___(?) {id=26,slot_type=optional__postfixExpression_1}
            |           |       |___Token:0 {id=44,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Constant]}
            |           |___Token:; {id=23,slot_type=Semi}
            |___Token:} {id=11,slot_type=RightBrace}
------------------------------------------------------------


==================Reducing node 2, size=38==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__translationUnit_3]remove whole except first
    #include <stdio.h>
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=5}
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__translationUnit_3]dd@1
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


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

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


==================Reducing node 5, size=38==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=5}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                 ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                 ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                 ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                 ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                       ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
        int a = 1;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
        int b = 2;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
        int c = 3;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
        int d = 4;
------------------------------------------------------------


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

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


==================Reducing node 8, size=38==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


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

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


=================Reducing node 10, size=38==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__compoundStatement_1]dd@1
    #include <stdio.h>
    int main(void)
    {
    }
------------------------------------------------------------


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

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


=================Reducing node 13, size=38==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=13}
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]remove whole except first
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@3
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

    size before clearance = 16
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@3
    #include <stdio.h>
    int main(void)
    {
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    #include <stdio.h>
    int main(void)
    {
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(void)
    {
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

Succeeded to reduce node 13 from 38 to 35
------------------------------------------------------------


=================Reducing node 46, size=35==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=46}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
                       ;
    }
------------------------------------------------------------


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

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


=================Reducing node 47, size=35==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
                       ;
    }
------------------------------------------------------------


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

Failed to reduce node 47
------------------------------------------------------------


=================Reducing node 64, size=35==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=64}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf         ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
               "%d"    ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
               "%d", a ;
    }
------------------------------------------------------------


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

Failed to reduce node 64
------------------------------------------------------------


=================Reducing node 221, size=35=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=221}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
                 ;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 221
------------------------------------------------------------


=================Reducing node 185, size=35=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=185}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
                 ;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 185
------------------------------------------------------------


=================Reducing node 149, size=35=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=149}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
                 ;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 113, size=35=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=113}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

    size before clearance = 17
------------------------------------------------------------


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

Succeeded to reduce node 113 from 35 to 31
------------------------------------------------------------


=================Reducing node 66, size=31==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__postfixExpression_2]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf         ;
    }
------------------------------------------------------------


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

Failed to reduce node 66
------------------------------------------------------------


=================Reducing node 68, size=31==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=68}
------------------------------------------------------------


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

Failed to reduce node 68
------------------------------------------------------------


=================Reducing node 256, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 256
------------------------------------------------------------


=================Reducing node 258, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__directDeclarator_7]dd@1
    #include <stdio.h>
    int main
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 258
------------------------------------------------------------


=================Reducing node 260, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=260}
------------------------------------------------------------


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

Failed to reduce node 260
------------------------------------------------------------


=================Reducing node 223, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    #include <stdio.h>
    int main(void)
    {
        int      ;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 223
------------------------------------------------------------


=================Reducing node 226, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=226}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a    ;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 187, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int      ;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 187
------------------------------------------------------------


=================Reducing node 190, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=190}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b    ;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 190
------------------------------------------------------------


=================Reducing node 151, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int      ;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 154, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=154}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c    ;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 154
------------------------------------------------------------


=================Reducing node 70, size=31==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf(       );
    }
------------------------------------------------------------


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

Failed to reduce node 70
------------------------------------------------------------


=================Reducing node 72, size=31==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=72}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf(      a);
    }
------------------------------------------------------------


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

Failed to reduce node 72
------------------------------------------------------------


=================Reducing node 228, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a    ;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 228
------------------------------------------------------------


=================Reducing node 229, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=229}
------------------------------------------------------------


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

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


=================Reducing node 192, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b    ;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 192
------------------------------------------------------------


=================Reducing node 193, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=193}
------------------------------------------------------------


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

Failed to reduce node 193
------------------------------------------------------------


=================Reducing node 156, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c    ;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 156
------------------------------------------------------------


=================Reducing node 157, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=157}
------------------------------------------------------------


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

Failed to reduce node 157
------------------------------------------------------------


=================Reducing node 74, size=31==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__expression_1]dd@1
    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d"   );
    }
------------------------------------------------------------


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

Failed to reduce node 74
------------------------------------------------------------


=================Reducing node 75, size=31==================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=75}
------------------------------------------------------------


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

Failed to reduce node 75
------------------------------------------------------------


=================Reducing node 279, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 279
------------------------------------------------------------


=================Reducing node 273, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 273
------------------------------------------------------------


=================Reducing node 267, size=31=================

The current best program is the following

    #include <stdio.h>
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:declarationSpecifiers]can be epsilon
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

    size before clearance = 18
------------------------------------------------------------


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

Succeeded to reduce node 267 from 31 to 30
------------------------------------------------------------


=================Reducing node 263, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 263
------------------------------------------------------------


=================Reducing node 261, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 261
------------------------------------------------------------


=================Reducing node 251, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 251
------------------------------------------------------------


=================Reducing node 248, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 248
------------------------------------------------------------


=================Reducing node 230, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 230
------------------------------------------------------------


=================Reducing node 224, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 224
------------------------------------------------------------


=================Reducing node 222, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 222
------------------------------------------------------------


=================Reducing node 255, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 255
------------------------------------------------------------


=================Reducing node 215, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 215
------------------------------------------------------------


=================Reducing node 212, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 212
------------------------------------------------------------


=================Reducing node 194, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 194
------------------------------------------------------------


=================Reducing node 188, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 188
------------------------------------------------------------


=================Reducing node 186, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 186
------------------------------------------------------------


=================Reducing node 219, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 219
------------------------------------------------------------


=================Reducing node 179, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 176, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 158, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 158
------------------------------------------------------------


=================Reducing node 152, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 150, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 183, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 183
------------------------------------------------------------


=================Reducing node 116, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 111, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 111
------------------------------------------------------------


=================Reducing node 109, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 110, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 110
------------------------------------------------------------


=================Reducing node 93, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 93
------------------------------------------------------------


=================Reducing node 76, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 76
------------------------------------------------------------


=================Reducing node 71, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 71
------------------------------------------------------------


=================Reducing node 69, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 69
------------------------------------------------------------


=================Reducing node 48, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 11, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 11
------------------------------------------------------------


==================Reducing node 9, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


==================Reducing node 6, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__functionDefinition_2]dd@1
    #include <stdio.h>
        main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 6
------------------------------------------------------------


=================Reducing node 274, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=274}
------------------------------------------------------------


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

Failed to reduce node 274
------------------------------------------------------------


=================Reducing node 278, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 278
------------------------------------------------------------


=Fixpoint iteration 2. Reducer: perses_node_priority_with_dfs_delta

The spar-tree is the following.
translationUnit {id=1}
|___(+) {id=2,slot_type=kleene_plus__translationUnit_3}
    |___Token:#include <stdio.h> {id=279,slot_type=[aux_rule__translationUnit_2,IncludeDirective]}
    |___functionDefinition {id=5,slot_type=[aux_rule__translationUnit_2,functionDefinition]}
        |___(?) {id=6,slot_type=optional__functionDefinition_2}
        |   |___(+) {id=274,slot_type=declarationSpecifiers}
        |       |___Token:int {id=278,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=256,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=273,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=258,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=260,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=261,slot_type=LeftParen}
        |           |___Token:) {id=263,slot_type=RightParen}
        |___compoundStatement {id=8,slot_type=compoundStatement}
            |___Token:{ {id=9,slot_type=LeftBrace}
            |___(?) {id=10,slot_type=optional__compoundStatement_1}
            |   |___(+) {id=13,slot_type=[blockItemList,kleene_plus__blockItemList_3]}
            |       |___aux_rule__declaration_3 {id=221,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=222,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=255,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=223,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=226,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:a {id=251,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=228,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=229,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=230,slot_type=Assign}
            |       |   |               |___Token:1 {id=248,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=224,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=185,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=186,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=219,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=187,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=190,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:b {id=215,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=192,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=193,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=194,slot_type=Assign}
            |       |   |               |___Token:2 {id=212,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=188,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=149,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=150,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=183,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=151,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=154,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:c {id=179,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=156,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=157,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=158,slot_type=Assign}
            |       |   |               |___Token:3 {id=176,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=152,slot_type=Semi}
            |       |___Token:; {id=116,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3,Semi]}
            |       |___expressionStatement {id=46,slot_type=[aux_rule__blockItemList_2,statement,expressionStatement]}
            |           |___(?) {id=47,slot_type=optional__postfixExpression_1}
            |           |   |___postfixExpression {id=64,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression]}
            |           |       |___Token:printf {id=111,slot_type=[aux_rule__postfixExpression_4,Identifier]}
            |           |       |___(*) {id=66,slot_type=kleene_star__postfixExpression_2}
            |           |           |___aux_rule__postfixExpression_11 {id=68,slot_type=[aux_rule__postfixExpression_3,aux_rule__postfixExpression_11]}
            |           |               |___Token:( {id=69,slot_type=LeftParen}
            |           |               |___(?) {id=70,slot_type=optional__postfixExpression_1}
            |           |               |   |___expression {id=72,slot_type=expression}
            |           |               |       |___(+) {id=109,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,kleene_plus__primaryExpression_1]}
            |           |               |       |   |___Token:"%d" {id=110,slot_type=StringLiteral}
            |           |               |       |___(*) {id=74,slot_type=kleene_star__expression_1}
            |           |               |           |___aux_rule__expression_2 {id=75,slot_type=aux_rule__expression_2}
            |           |               |               |___Token:, {id=76,slot_type=Comma}
            |           |               |               |___Token:a {id=93,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |           |               |___Token:) {id=71,slot_type=RightParen}
            |           |___Token:; {id=48,slot_type=Semi}
            |___Token:} {id=11,slot_type=RightBrace}
------------------------------------------------------------


==================Reducing node 2, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__translationUnit_3]remove whole except first
    #include <stdio.h>
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=5}
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__translationUnit_3]dd@1
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


==================Reducing node 5, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=5}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                 ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                 ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                 ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                 ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
                       ;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
        int a = 1;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
        int b = 2;
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
        int c = 3;
------------------------------------------------------------


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

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


==================Reducing node 8, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 10, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__compoundStatement_1]dd@1
    #include <stdio.h>
    int main(    )
    {
    }
------------------------------------------------------------


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

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


=================Reducing node 13, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=13}
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]remove whole except first
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@3
    #include <stdio.h>
    int main(    )
    {
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    #include <stdio.h>
    int main(    )
    {
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    #include <stdio.h>
    int main(    )
    {
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 13
------------------------------------------------------------


=================Reducing node 46, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=46}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
                       ;
    }
------------------------------------------------------------


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

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


=================Reducing node 47, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
                       ;
    }
------------------------------------------------------------


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

Failed to reduce node 47
------------------------------------------------------------


=================Reducing node 64, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=64}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf         ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
               "%d"    ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
               "%d", a ;
    }
------------------------------------------------------------


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

Failed to reduce node 64
------------------------------------------------------------


=================Reducing node 221, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=221}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
                 ;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 221
------------------------------------------------------------


=================Reducing node 185, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=185}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
                 ;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 185
------------------------------------------------------------


=================Reducing node 149, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=149}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
                 ;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 66, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__postfixExpression_2]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf         ;
    }
------------------------------------------------------------


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

Failed to reduce node 66
------------------------------------------------------------


=================Reducing node 68, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=68}
------------------------------------------------------------


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

Failed to reduce node 68
------------------------------------------------------------


=================Reducing node 256, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 256
------------------------------------------------------------


=================Reducing node 223, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    #include <stdio.h>
    int main(    )
    {
        int      ;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 223
------------------------------------------------------------


=================Reducing node 226, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=226}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a    ;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 187, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int      ;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 187
------------------------------------------------------------


=================Reducing node 190, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=190}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b    ;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 190
------------------------------------------------------------


=================Reducing node 151, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int      ;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 154, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=154}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c    ;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 154
------------------------------------------------------------


=================Reducing node 70, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf(       );
    }
------------------------------------------------------------


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

Failed to reduce node 70
------------------------------------------------------------


=================Reducing node 72, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=72}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf(      a);
    }
------------------------------------------------------------


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

Failed to reduce node 72
------------------------------------------------------------


=================Reducing node 258, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__directDeclarator_7]dd@1
    #include <stdio.h>
    int main
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 258
------------------------------------------------------------


=================Reducing node 260, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=260}
------------------------------------------------------------


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

Failed to reduce node 260
------------------------------------------------------------


=================Reducing node 228, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a    ;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 228
------------------------------------------------------------


=================Reducing node 229, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=229}
------------------------------------------------------------


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

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


=================Reducing node 192, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b    ;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 192
------------------------------------------------------------


=================Reducing node 193, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=193}
------------------------------------------------------------


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

Failed to reduce node 193
------------------------------------------------------------


=================Reducing node 156, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c    ;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 156
------------------------------------------------------------


=================Reducing node 157, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=157}
------------------------------------------------------------


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

Failed to reduce node 157
------------------------------------------------------------


=================Reducing node 74, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__expression_1]dd@1
    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d"   );
    }
------------------------------------------------------------


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

Failed to reduce node 74
------------------------------------------------------------


=================Reducing node 75, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=75}
------------------------------------------------------------


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

Failed to reduce node 75
------------------------------------------------------------


=================Reducing node 279, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 279
------------------------------------------------------------


=================Reducing node 273, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 273
------------------------------------------------------------


=================Reducing node 263, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 263
------------------------------------------------------------


=================Reducing node 261, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 261
------------------------------------------------------------


=================Reducing node 251, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 251
------------------------------------------------------------


=================Reducing node 248, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 248
------------------------------------------------------------


=================Reducing node 230, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 230
------------------------------------------------------------


=================Reducing node 224, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 224
------------------------------------------------------------


=================Reducing node 222, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 222
------------------------------------------------------------


=================Reducing node 255, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 255
------------------------------------------------------------


=================Reducing node 215, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 215
------------------------------------------------------------


=================Reducing node 212, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 212
------------------------------------------------------------


=================Reducing node 194, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 194
------------------------------------------------------------


=================Reducing node 188, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 188
------------------------------------------------------------


=================Reducing node 186, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 186
------------------------------------------------------------


=================Reducing node 219, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 219
------------------------------------------------------------


=================Reducing node 179, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 176, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 158, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 158
------------------------------------------------------------


=================Reducing node 152, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 150, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 183, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 183
------------------------------------------------------------


=================Reducing node 116, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 111, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 111
------------------------------------------------------------


=================Reducing node 109, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 110, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 110
------------------------------------------------------------


=================Reducing node 93, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 93
------------------------------------------------------------


=================Reducing node 76, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 76
------------------------------------------------------------


=================Reducing node 71, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 71
------------------------------------------------------------


=================Reducing node 69, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 69
------------------------------------------------------------


=================Reducing node 48, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 11, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 11
------------------------------------------------------------


==================Reducing node 9, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


==================Reducing node 6, size=30==================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=274}
------------------------------------------------------------


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

Failed to reduce node 6
------------------------------------------------------------


=================Reducing node 274, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


==============Node edit action set cache hit.===============

    NodeDeletionAction{target_node=274}
------------------------------------------------------------


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

Failed to reduce node 274
------------------------------------------------------------


=================Reducing node 278, size=30=================

The current best program is the following

    #include <stdio.h>
    int main(    )
    {
        int a = 1;
        int b = 2;
        int c = 3;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 278
------------------------------------------------------------


#test success = 3
#test failure = 94
#test result cache hits = 0
#test execution cancelled = 0
#node edit action set cache hits = 40
#external test execution cache hits = 0
