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

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


=Fixpoint iteration 1. Reducer: customized_tree_diff_node_reducer

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 113, 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: pass=============

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


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

It took less than 1 second to cancel the task.

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


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

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


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

    size before clearance = 2
------------------------------------------------------------


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

Succeeded to reduce node 113 from 38 to 33
------------------------------------------------------------


=================Reducing node 93, size=33==================

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);
        return 0;
    }
------------------------------------------------------------


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

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


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

The initial program size is 36
------------------------------------------------------------


=Fixpoint iteration 1. Reducer: customized_tree_diff_node_reducer

The spar-tree is the following.
translationUnit {id=1}
|___(+) {id=2,slot_type=kleene_plus__translationUnit_3}
    |___Token:#include <stdio.h> {id=268,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=263,slot_type=declarationSpecifiers}
        |       |___Token:int {id=267,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=245,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=262,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=247,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=249,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=250,slot_type=LeftParen}
        |           |___(+) {id=256,slot_type=[altnt_block__directDeclarator_11,parameterTypeList,parameterList,parameterDeclaration,declarationSpecifiers]}
        |           |   |___Token:void {id=261,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Void]}
        |           |___Token:) {id=252,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=210,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=211,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=244,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=212,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=215,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:a {id=240,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=217,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=218,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=219,slot_type=Assign}
            |       |   |               |___Token:1 {id=237,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=213,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=174,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=175,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=208,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=176,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=179,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:b {id=204,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=181,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=182,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=183,slot_type=Assign}
            |       |   |               |___Token:2 {id=201,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=177,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=138,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=139,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=172,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=140,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=143,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:c {id=168,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=145,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=146,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=147,slot_type=Assign}
            |       |   |               |___Token:3 {id=165,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=141,slot_type=Semi}
            |       |___expressionStatement {id=113,slot_type=[aux_rule__blockItemList_2,statement,expressionStatement]}
            |       |   |___(?) {id=114,slot_type=optional__postfixExpression_1}
            |       |   |   |___postfixExpression {id=131,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression]}
            |       |   |       |___Token:b {id=136,slot_type=[aux_rule__postfixExpression_4,Identifier]}
            |       |   |       |___(*) {id=133,slot_type=kleene_star__postfixExpression_2}
            |       |   |           |___Token:++ {id=135,slot_type=[aux_rule__postfixExpression_3,PlusPlus]}
            |       |   |___Token:; {id=115,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:c {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 113, size=36=================

The current best program is the following

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


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

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


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

It took less than 1 second to cancel the task.

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


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

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


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

    size before clearance = 2
------------------------------------------------------------


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

Succeeded to reduce node 113 from 36 to 33
------------------------------------------------------------


=================Reducing node 93, size=33==================

The current best program is the following

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


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

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


#test success = 1
#test failure = 0
#test result cache hits = 0
#test execution cancelled = 1
#node edit action set cache hits = 0
#external test execution cache hits = 0
Reduction starts.
Current diff:
	<a, c>
Reducer ListDiffSlicer ends.
Current diff:
	<a, c>
Reducer ListDiffDdmin ends.
Current diff:
	<a, c>
Reduction ends.
Current diff:
	<a, c>
Reduction starts.
Current diff:
	<c, a>
Reducer ListDiffSlicer ends.
Current diff:
	<c, a>
Reducer ListDiffDdmin ends.
Current diff:
	<c, a>
Reduction ends.
Current diff:
	<c, a>
=====================Reduction starts.======================

The initial program size is 33
------------------------------------------------------------


=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=242,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=237,slot_type=declarationSpecifiers}
        |       |___Token:int {id=241,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=219,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=236,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=221,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=223,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=224,slot_type=LeftParen}
        |           |___(+) {id=230,slot_type=[altnt_block__directDeclarator_11,parameterTypeList,parameterList,parameterDeclaration,declarationSpecifiers]}
        |           |   |___Token:void {id=235,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Void]}
        |           |___Token:) {id=226,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=184,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=185,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=218,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=186,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=189,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:a {id=214,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=191,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=192,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=193,slot_type=Assign}
            |       |   |               |___Token:1 {id=211,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=187,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=148,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=149,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=182,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=150,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=153,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:b {id=178,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=155,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=156,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=157,slot_type=Assign}
            |       |   |               |___Token:2 {id=175,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=151,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=112,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=113,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=146,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=114,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=117,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:c {id=142,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=119,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=120,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=121,slot_type=Assign}
            |       |   |               |___Token:3 {id=139,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=115,slot_type=Semi}
            |       |___expressionStatement {id=45,slot_type=[aux_rule__blockItemList_2,statement,expressionStatement]}
            |       |   |___(?) {id=46,slot_type=optional__postfixExpression_1}
            |       |   |   |___postfixExpression {id=63,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression]}
            |       |   |       |___Token:printf {id=110,slot_type=[aux_rule__postfixExpression_4,Identifier]}
            |       |   |       |___(*) {id=65,slot_type=kleene_star__postfixExpression_2}
            |       |   |           |___aux_rule__postfixExpression_11 {id=67,slot_type=[aux_rule__postfixExpression_3,aux_rule__postfixExpression_11]}
            |       |   |               |___Token:( {id=68,slot_type=LeftParen}
            |       |   |               |___(?) {id=69,slot_type=optional__postfixExpression_1}
            |       |   |               |   |___expression {id=71,slot_type=expression}
            |       |   |               |       |___(+) {id=108,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=109,slot_type=StringLiteral}
            |       |   |               |       |___(*) {id=73,slot_type=kleene_star__expression_1}
            |       |   |               |           |___aux_rule__expression_2 {id=74,slot_type=aux_rule__expression_2}
            |       |   |               |               |___Token:, {id=75,slot_type=Comma}
            |       |   |               |               |___Token:a {id=92,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |       |   |               |___Token:) {id=70,slot_type=RightParen}
            |       |   |___Token:; {id=47,slot_type=Semi}
            |       |___jumpStatement {id=20,slot_type=[aux_rule__blockItemList_2,statement,jumpStatement]}
            |           |___aux_rule__jumpStatement_4 {id=23,slot_type=[altnt_block__jumpStatement_2,aux_rule__jumpStatement_4]}
            |           |   |___Token:return {id=24,slot_type=Return}
            |           |   |___(?) {id=25,slot_type=optional__postfixExpression_1}
            |           |       |___Token:0 {id=43,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=22,slot_type=Semi}
            |___Token:} {id=11,slot_type=RightBrace}
------------------------------------------------------------


==================Reducing node 2, size=33==================

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);
        return 0;
    }
------------------------------------------------------------


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

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


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

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


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

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


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

    size before clearance = 2
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__translationUnit_3]dd@1
------------------------------------------------------------


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

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


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

Succeeded to reduce node 2 from 33 to 32
------------------------------------------------------------


==================Reducing node 5, size=32==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


==================Reducing node 8, size=32==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


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

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


=================Reducing node 10, size=32==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 13, size=32==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        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
    int main(void)
    {
        int a = 1;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@3
    int main(void)
    {
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    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@2
    int main(void)
    {
        int c = 3;
        printf("%d", a);
        return 0;
    }
------------------------------------------------------------


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

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


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main(void)
    {
        int a = 1;
        int b = 2;
        int c = 3;
        return 0;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    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
------------------------------------------------------------


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

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


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main(void)
    {
        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@1
    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
    int main(void)
    {
        int b = 2;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


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

    size before clearance = 5
------------------------------------------------------------


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

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


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

Succeeded to reduce node 13 from 32 to 24
------------------------------------------------------------


=================Reducing node 45, size=24==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [regular_node]can be epsilon
    int main(void)
    {
        int a = 1;
        int c = 3;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a = 1;
        int c = 3;
                       ;
    }
------------------------------------------------------------


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

Failed to reduce node 45
------------------------------------------------------------


=================Reducing node 46, size=24==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main(void)
    {
        int a = 1;
        int c = 3;
                       ;
    }
------------------------------------------------------------


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

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


=================Reducing node 63, size=24==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=63}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a = 1;
        int c = 3;
        printf         ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a = 1;
        int c = 3;
               "%d"    ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a = 1;
        int c = 3;
               "%d", a ;
    }
------------------------------------------------------------


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

Failed to reduce node 63
------------------------------------------------------------


=================Reducing node 184, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=184}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
                 ;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 184
------------------------------------------------------------


=================Reducing node 112, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [regular_node]can be epsilon
    int main(void)
    {
        int a = 1;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a = 1;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 65, size=24==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__postfixExpression_2]dd@1
    int main(void)
    {
        int a = 1;
        int c = 3;
        printf         ;
    }
------------------------------------------------------------


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

Failed to reduce node 65
------------------------------------------------------------


=================Reducing node 67, size=24==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=67}
------------------------------------------------------------


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

Failed to reduce node 67
------------------------------------------------------------


=================Reducing node 219, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 221, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 223, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=223}
------------------------------------------------------------


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

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


=================Reducing node 186, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 189, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=189}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a    ;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 189
------------------------------------------------------------


=================Reducing node 114, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    int main(void)
    {
        int a = 1;
        int      ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 114
------------------------------------------------------------


=================Reducing node 117, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=117}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a = 1;
        int c    ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 69, size=24==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main(void)
    {
        int a = 1;
        int c = 3;
        printf(       );
    }
------------------------------------------------------------


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

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


=================Reducing node 71, size=24==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=71}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(void)
    {
        int a = 1;
        int c = 3;
        printf(      a);
    }
------------------------------------------------------------


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

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


=================Reducing node 191, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

Failed to reduce node 191
------------------------------------------------------------


=================Reducing node 192, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=192}
------------------------------------------------------------


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

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


=================Reducing node 119, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    int main(void)
    {
        int a = 1;
        int c    ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 120, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=120}
------------------------------------------------------------


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

Failed to reduce node 120
------------------------------------------------------------


=================Reducing node 73, size=24==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__expression_1]dd@1
    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

Failed to reduce node 73
------------------------------------------------------------


=================Reducing node 74, size=24==================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=74}
------------------------------------------------------------


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

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


=================Reducing node 236, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 230, size=24=================

The current best program is the following

    int main(void)
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:declarationSpecifiers]can be epsilon
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

    size before clearance = 25
------------------------------------------------------------


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

Succeeded to reduce node 230 from 24 to 23
------------------------------------------------------------


=================Reducing node 226, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 224, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 214, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 214
------------------------------------------------------------


=================Reducing node 211, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 211
------------------------------------------------------------


=================Reducing node 193, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 187, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 185, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 218, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 218
------------------------------------------------------------


=================Reducing node 142, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 139, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 121, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 115, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 115
------------------------------------------------------------


=================Reducing node 113, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 113
------------------------------------------------------------


=================Reducing node 146, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 146
------------------------------------------------------------


=================Reducing node 110, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 108, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 108
------------------------------------------------------------


=================Reducing node 109, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 92, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 92
------------------------------------------------------------


=================Reducing node 75, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 70, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 68, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 47, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 11, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


==================Reducing node 9, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


==================Reducing node 6, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 237, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=237}
------------------------------------------------------------


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

Failed to reduce node 237
------------------------------------------------------------


=================Reducing node 241, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


#test success = 4
#test failure = 46
#test result cache hits = 0
#test execution cancelled = 0
#node edit action set cache hits = 13
#external test execution cache hits = 0
=====================Reduction starts.======================

The initial program size is 23
------------------------------------------------------------


=Fixpoint iteration 1. Reducer: perses_node_priority_with_dfs_delta

The spar-tree is the following.
translationUnit {id=1}
|___(+) {id=2,slot_type=kleene_plus__translationUnit_3}
    |___functionDefinition {id=4,slot_type=[aux_rule__translationUnit_2,functionDefinition]}
        |___(?) {id=5,slot_type=optional__functionDefinition_2}
        |   |___(+) {id=164,slot_type=declarationSpecifiers}
        |       |___Token:int {id=168,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=155,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=163,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=157,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=159,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=160,slot_type=LeftParen}
        |           |___Token:) {id=162,slot_type=RightParen}
        |___compoundStatement {id=7,slot_type=compoundStatement}
            |___Token:{ {id=8,slot_type=LeftBrace}
            |___(?) {id=9,slot_type=optional__compoundStatement_1}
            |   |___(+) {id=12,slot_type=[blockItemList,kleene_plus__blockItemList_3]}
            |       |___aux_rule__declaration_3 {id=120,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=121,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=154,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=122,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=125,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:a {id=150,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=127,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=128,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=129,slot_type=Assign}
            |       |   |               |___Token:1 {id=147,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=123,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=84,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=85,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=118,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=86,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=89,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:c {id=114,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=91,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=92,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=93,slot_type=Assign}
            |       |   |               |___Token:3 {id=111,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=87,slot_type=Semi}
            |       |___expressionStatement {id=17,slot_type=[aux_rule__blockItemList_2,statement,expressionStatement]}
            |           |___(?) {id=18,slot_type=optional__postfixExpression_1}
            |           |   |___postfixExpression {id=35,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression]}
            |           |       |___Token:printf {id=82,slot_type=[aux_rule__postfixExpression_4,Identifier]}
            |           |       |___(*) {id=37,slot_type=kleene_star__postfixExpression_2}
            |           |           |___aux_rule__postfixExpression_11 {id=39,slot_type=[aux_rule__postfixExpression_3,aux_rule__postfixExpression_11]}
            |           |               |___Token:( {id=40,slot_type=LeftParen}
            |           |               |___(?) {id=41,slot_type=optional__postfixExpression_1}
            |           |               |   |___expression {id=43,slot_type=expression}
            |           |               |       |___(+) {id=80,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=81,slot_type=StringLiteral}
            |           |               |       |___(*) {id=45,slot_type=kleene_star__expression_1}
            |           |               |           |___aux_rule__expression_2 {id=46,slot_type=aux_rule__expression_2}
            |           |               |               |___Token:, {id=47,slot_type=Comma}
            |           |               |               |___Token:c {id=64,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |           |               |___Token:) {id=42,slot_type=RightParen}
            |           |___Token:; {id=19,slot_type=Semi}
            |___Token:} {id=10,slot_type=RightBrace}
------------------------------------------------------------


==================Reducing node 2, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


==================Reducing node 4, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


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

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


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

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


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

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


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

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


==================Reducing node 7, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


==================Reducing node 9, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 12, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=12}
------------------------------------------------------------


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

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


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    int main(    )
    {
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
    }
------------------------------------------------------------


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

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


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

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


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

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


=================Reducing node 17, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=17}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
                       ;
    }
------------------------------------------------------------


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

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


=================Reducing node 18, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
                       ;
    }
------------------------------------------------------------


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

Failed to reduce node 18
------------------------------------------------------------


=================Reducing node 35, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=35}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf         ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
               "%d"    ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
               "%d", c ;
    }
------------------------------------------------------------


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

Failed to reduce node 35
------------------------------------------------------------


=================Reducing node 120, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=120}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
                 ;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 120
------------------------------------------------------------


=================Reducing node 84, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=84}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
                 ;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 37, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__postfixExpression_2]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf         ;
    }
------------------------------------------------------------


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

Failed to reduce node 37
------------------------------------------------------------


=================Reducing node 39, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=39}
------------------------------------------------------------


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

Failed to reduce node 39
------------------------------------------------------------


=================Reducing node 155, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

Failed to reduce node 155
------------------------------------------------------------


=================Reducing node 122, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    int main(    )
    {
        int      ;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 125, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=125}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a    ;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 86, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    int main(    )
    {
        int a = 1;
        int      ;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 86
------------------------------------------------------------


=================Reducing node 89, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=89}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c    ;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 41, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf(       );
    }
------------------------------------------------------------


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

Failed to reduce node 41
------------------------------------------------------------


=================Reducing node 43, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=43}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf(      c);
    }
------------------------------------------------------------


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

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


=================Reducing node 157, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 159, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=159}
------------------------------------------------------------


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

Failed to reduce node 159
------------------------------------------------------------


=================Reducing node 127, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

Failed to reduce node 127
------------------------------------------------------------


=================Reducing node 128, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=128}
------------------------------------------------------------


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

Failed to reduce node 128
------------------------------------------------------------


=================Reducing node 91, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    int main(    )
    {
        int a = 1;
        int c    ;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 92, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=92}
------------------------------------------------------------


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

Failed to reduce node 92
------------------------------------------------------------


=================Reducing node 45, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__expression_1]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

Failed to reduce node 45
------------------------------------------------------------


=================Reducing node 46, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 163, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 163
------------------------------------------------------------


=================Reducing node 162, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 162
------------------------------------------------------------


=================Reducing node 160, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 160
------------------------------------------------------------


=================Reducing node 150, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 147, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 129, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 129
------------------------------------------------------------


=================Reducing node 123, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 123
------------------------------------------------------------


=================Reducing node 121, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 154, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 114, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 114
------------------------------------------------------------


=================Reducing node 111, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 93, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 87, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 85, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 118, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 118
------------------------------------------------------------


=================Reducing node 82, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 80, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 81, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 81
------------------------------------------------------------


=================Reducing node 64, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 47, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 42, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 40, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 19, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 10, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


==================Reducing node 8, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


==================Reducing node 5, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 164, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=164}
------------------------------------------------------------


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

Failed to reduce node 164
------------------------------------------------------------


=================Reducing node 168, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 168
------------------------------------------------------------


#test success = 0
#test failure = 33
#test result cache hits = 0
#test execution cancelled = 0
#node edit action set cache hits = 14
#external test execution cache hits = 0
=====================Reduction starts.======================

The initial program size is 23
------------------------------------------------------------


=Fixpoint iteration 1. Reducer: customized_tree_diff_node_reducer

The spar-tree is the following.
translationUnit {id=1}
|___(+) {id=2,slot_type=kleene_plus__translationUnit_3}
    |___functionDefinition {id=4,slot_type=[aux_rule__translationUnit_2,functionDefinition]}
        |___(?) {id=5,slot_type=optional__functionDefinition_2}
        |   |___(+) {id=164,slot_type=declarationSpecifiers}
        |       |___Token:int {id=168,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=155,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=163,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=157,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=159,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=160,slot_type=LeftParen}
        |           |___Token:) {id=162,slot_type=RightParen}
        |___compoundStatement {id=7,slot_type=compoundStatement}
            |___Token:{ {id=8,slot_type=LeftBrace}
            |___(?) {id=9,slot_type=optional__compoundStatement_1}
            |   |___(+) {id=12,slot_type=[blockItemList,kleene_plus__blockItemList_3]}
            |       |___aux_rule__declaration_3 {id=120,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=121,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=154,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=122,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=125,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:a {id=150,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=127,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=128,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=129,slot_type=Assign}
            |       |   |               |___Token:1 {id=147,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=123,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=84,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=85,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=118,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=86,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=89,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:c {id=114,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=91,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=92,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=93,slot_type=Assign}
            |       |   |               |___Token:3 {id=111,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=87,slot_type=Semi}
            |       |___expressionStatement {id=17,slot_type=[aux_rule__blockItemList_2,statement,expressionStatement]}
            |           |___(?) {id=18,slot_type=optional__postfixExpression_1}
            |           |   |___postfixExpression {id=35,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression]}
            |           |       |___Token:printf {id=82,slot_type=[aux_rule__postfixExpression_4,Identifier]}
            |           |       |___(*) {id=37,slot_type=kleene_star__postfixExpression_2}
            |           |           |___aux_rule__postfixExpression_11 {id=39,slot_type=[aux_rule__postfixExpression_3,aux_rule__postfixExpression_11]}
            |           |               |___Token:( {id=40,slot_type=LeftParen}
            |           |               |___(?) {id=41,slot_type=optional__postfixExpression_1}
            |           |               |   |___expression {id=43,slot_type=expression}
            |           |               |       |___(+) {id=80,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=81,slot_type=StringLiteral}
            |           |               |       |___(*) {id=45,slot_type=kleene_star__expression_1}
            |           |               |           |___aux_rule__expression_2 {id=46,slot_type=aux_rule__expression_2}
            |           |               |               |___Token:, {id=47,slot_type=Comma}
            |           |               |               |___Token:a {id=64,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |           |               |___Token:) {id=42,slot_type=RightParen}
            |           |___Token:; {id=19,slot_type=Semi}
            |___Token:} {id=10,slot_type=RightBrace}
------------------------------------------------------------


=================Reducing node 64, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


#test success = 0
#test failure = 0
#test result cache hits = 0
#test execution cancelled = 0
#node edit action set cache hits = 0
#external test execution cache hits = 0
=====================Reduction starts.======================

The initial program size is 23
------------------------------------------------------------


=Fixpoint iteration 1. Reducer: customized_tree_diff_node_reducer

The spar-tree is the following.
translationUnit {id=1}
|___(+) {id=2,slot_type=kleene_plus__translationUnit_3}
    |___functionDefinition {id=4,slot_type=[aux_rule__translationUnit_2,functionDefinition]}
        |___(?) {id=5,slot_type=optional__functionDefinition_2}
        |   |___(+) {id=164,slot_type=declarationSpecifiers}
        |       |___Token:int {id=168,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=155,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=163,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=157,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=159,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=160,slot_type=LeftParen}
        |           |___Token:) {id=162,slot_type=RightParen}
        |___compoundStatement {id=7,slot_type=compoundStatement}
            |___Token:{ {id=8,slot_type=LeftBrace}
            |___(?) {id=9,slot_type=optional__compoundStatement_1}
            |   |___(+) {id=12,slot_type=[blockItemList,kleene_plus__blockItemList_3]}
            |       |___aux_rule__declaration_3 {id=120,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=121,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=154,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=122,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=125,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:a {id=150,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=127,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=128,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=129,slot_type=Assign}
            |       |   |               |___Token:1 {id=147,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=123,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=84,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=85,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=118,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=86,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=89,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:c {id=114,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=91,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=92,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=93,slot_type=Assign}
            |       |   |               |___Token:3 {id=111,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=87,slot_type=Semi}
            |       |___expressionStatement {id=17,slot_type=[aux_rule__blockItemList_2,statement,expressionStatement]}
            |           |___(?) {id=18,slot_type=optional__postfixExpression_1}
            |           |   |___postfixExpression {id=35,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression]}
            |           |       |___Token:printf {id=82,slot_type=[aux_rule__postfixExpression_4,Identifier]}
            |           |       |___(*) {id=37,slot_type=kleene_star__postfixExpression_2}
            |           |           |___aux_rule__postfixExpression_11 {id=39,slot_type=[aux_rule__postfixExpression_3,aux_rule__postfixExpression_11]}
            |           |               |___Token:( {id=40,slot_type=LeftParen}
            |           |               |___(?) {id=41,slot_type=optional__postfixExpression_1}
            |           |               |   |___expression {id=43,slot_type=expression}
            |           |               |       |___(+) {id=80,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=81,slot_type=StringLiteral}
            |           |               |       |___(*) {id=45,slot_type=kleene_star__expression_1}
            |           |               |           |___aux_rule__expression_2 {id=46,slot_type=aux_rule__expression_2}
            |           |               |               |___Token:, {id=47,slot_type=Comma}
            |           |               |               |___Token:c {id=64,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |           |               |___Token:) {id=42,slot_type=RightParen}
            |           |___Token:; {id=19,slot_type=Semi}
            |___Token:} {id=10,slot_type=RightBrace}
------------------------------------------------------------


=================Reducing node 64, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


#test success = 0
#test failure = 0
#test result cache hits = 0
#test execution cancelled = 0
#node edit action set cache hits = 0
#external test execution cache hits = 0
Reduction starts.
Current diff:
	<a, c>
Reducer ListDiffSlicer ends.
Current diff:
	<a, c>
Reducer ListDiffDdmin ends.
Current diff:
	<a, c>
Reduction ends.
Current diff:
	<a, c>
Reduction starts.
Current diff:
	<c, a>
Reducer ListDiffSlicer ends.
Current diff:
	<c, a>
Reducer ListDiffDdmin ends.
Current diff:
	<c, a>
Reduction ends.
Current diff:
	<c, a>
=====================Reduction starts.======================

The initial program size is 23
------------------------------------------------------------


=Fixpoint iteration 1. Reducer: perses_node_priority_with_dfs_delta

The spar-tree is the following.
translationUnit {id=1}
|___(+) {id=2,slot_type=kleene_plus__translationUnit_3}
    |___functionDefinition {id=4,slot_type=[aux_rule__translationUnit_2,functionDefinition]}
        |___(?) {id=5,slot_type=optional__functionDefinition_2}
        |   |___(+) {id=164,slot_type=declarationSpecifiers}
        |       |___Token:int {id=168,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=155,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=163,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=157,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=159,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=160,slot_type=LeftParen}
        |           |___Token:) {id=162,slot_type=RightParen}
        |___compoundStatement {id=7,slot_type=compoundStatement}
            |___Token:{ {id=8,slot_type=LeftBrace}
            |___(?) {id=9,slot_type=optional__compoundStatement_1}
            |   |___(+) {id=12,slot_type=[blockItemList,kleene_plus__blockItemList_3]}
            |       |___aux_rule__declaration_3 {id=120,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=121,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=154,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=122,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=125,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:a {id=150,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=127,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=128,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=129,slot_type=Assign}
            |       |   |               |___Token:1 {id=147,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=123,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=84,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=85,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=118,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=86,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=89,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:c {id=114,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=91,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=92,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=93,slot_type=Assign}
            |       |   |               |___Token:3 {id=111,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=87,slot_type=Semi}
            |       |___expressionStatement {id=17,slot_type=[aux_rule__blockItemList_2,statement,expressionStatement]}
            |           |___(?) {id=18,slot_type=optional__postfixExpression_1}
            |           |   |___postfixExpression {id=35,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression]}
            |           |       |___Token:printf {id=82,slot_type=[aux_rule__postfixExpression_4,Identifier]}
            |           |       |___(*) {id=37,slot_type=kleene_star__postfixExpression_2}
            |           |           |___aux_rule__postfixExpression_11 {id=39,slot_type=[aux_rule__postfixExpression_3,aux_rule__postfixExpression_11]}
            |           |               |___Token:( {id=40,slot_type=LeftParen}
            |           |               |___(?) {id=41,slot_type=optional__postfixExpression_1}
            |           |               |   |___expression {id=43,slot_type=expression}
            |           |               |       |___(+) {id=80,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=81,slot_type=StringLiteral}
            |           |               |       |___(*) {id=45,slot_type=kleene_star__expression_1}
            |           |               |           |___aux_rule__expression_2 {id=46,slot_type=aux_rule__expression_2}
            |           |               |               |___Token:, {id=47,slot_type=Comma}
            |           |               |               |___Token:a {id=64,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |           |               |___Token:) {id=42,slot_type=RightParen}
            |           |___Token:; {id=19,slot_type=Semi}
            |___Token:} {id=10,slot_type=RightBrace}
------------------------------------------------------------


==================Reducing node 2, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


==================Reducing node 4, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


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

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


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

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


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

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


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

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


==================Reducing node 7, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


==================Reducing node 9, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 12, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=12}
------------------------------------------------------------


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

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


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    int main(    )
    {
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    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
    int main(    )
    {
        int a = 1;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 17, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=17}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
                       ;
    }
------------------------------------------------------------


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

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


=================Reducing node 18, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
                       ;
    }
------------------------------------------------------------


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

Failed to reduce node 18
------------------------------------------------------------


=================Reducing node 35, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=35}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf         ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
               "%d"    ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
               "%d", a ;
    }
------------------------------------------------------------


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

Failed to reduce node 35
------------------------------------------------------------


=================Reducing node 120, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=120}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
                 ;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 120
------------------------------------------------------------


=================Reducing node 84, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=84}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
                 ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 37, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__postfixExpression_2]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf         ;
    }
------------------------------------------------------------


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

Failed to reduce node 37
------------------------------------------------------------


=================Reducing node 39, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=39}
------------------------------------------------------------


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

Failed to reduce node 39
------------------------------------------------------------


=================Reducing node 155, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

Failed to reduce node 155
------------------------------------------------------------


=================Reducing node 122, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 125, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=125}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a    ;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 86, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    int main(    )
    {
        int a = 1;
        int      ;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 86
------------------------------------------------------------


=================Reducing node 89, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=89}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c    ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 41, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf(       );
    }
------------------------------------------------------------


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

Failed to reduce node 41
------------------------------------------------------------


=================Reducing node 43, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=43}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf(      a);
    }
------------------------------------------------------------


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

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


=================Reducing node 157, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 159, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=159}
------------------------------------------------------------


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

Failed to reduce node 159
------------------------------------------------------------


=================Reducing node 127, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

Failed to reduce node 127
------------------------------------------------------------


=================Reducing node 128, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=128}
------------------------------------------------------------


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

Failed to reduce node 128
------------------------------------------------------------


=================Reducing node 91, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    int main(    )
    {
        int a = 1;
        int c    ;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 92, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=92}
------------------------------------------------------------


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

Failed to reduce node 92
------------------------------------------------------------


=================Reducing node 45, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__expression_1]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

Failed to reduce node 45
------------------------------------------------------------


=================Reducing node 46, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 163, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 163
------------------------------------------------------------


=================Reducing node 162, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 162
------------------------------------------------------------


=================Reducing node 160, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 160
------------------------------------------------------------


=================Reducing node 150, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 147, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 129, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 129
------------------------------------------------------------


=================Reducing node 123, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 123
------------------------------------------------------------


=================Reducing node 121, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 154, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 114, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 114
------------------------------------------------------------


=================Reducing node 111, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 93, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 87, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 85, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 118, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 118
------------------------------------------------------------


=================Reducing node 82, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 80, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 81, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 81
------------------------------------------------------------


=================Reducing node 64, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 47, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 42, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 40, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 19, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


=================Reducing node 10, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


==================Reducing node 8, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


==================Reducing node 5, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 164, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=164}
------------------------------------------------------------


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

Failed to reduce node 164
------------------------------------------------------------


=================Reducing node 168, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", a);
    }
------------------------------------------------------------


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

Failed to reduce node 168
------------------------------------------------------------


#test success = 0
#test failure = 33
#test result cache hits = 0
#test execution cancelled = 0
#node edit action set cache hits = 14
#external test execution cache hits = 0
=====================Reduction starts.======================

The initial program size is 23
------------------------------------------------------------


=Fixpoint iteration 1. Reducer: perses_node_priority_with_dfs_delta

The spar-tree is the following.
translationUnit {id=1}
|___(+) {id=2,slot_type=kleene_plus__translationUnit_3}
    |___functionDefinition {id=4,slot_type=[aux_rule__translationUnit_2,functionDefinition]}
        |___(?) {id=5,slot_type=optional__functionDefinition_2}
        |   |___(+) {id=164,slot_type=declarationSpecifiers}
        |       |___Token:int {id=168,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
        |___directDeclarator {id=155,slot_type=[declarator,directDeclarator]}
        |   |___Token:main {id=163,slot_type=[aux_rule__directDeclarator_9,Identifier]}
        |   |___(*) {id=157,slot_type=kleene_star__directDeclarator_7}
        |       |___aux_rule__directDeclarator_15 {id=159,slot_type=[aux_rule__directDeclarator_8,aux_rule__directDeclarator_15]}
        |           |___Token:( {id=160,slot_type=LeftParen}
        |           |___Token:) {id=162,slot_type=RightParen}
        |___compoundStatement {id=7,slot_type=compoundStatement}
            |___Token:{ {id=8,slot_type=LeftBrace}
            |___(?) {id=9,slot_type=optional__compoundStatement_1}
            |   |___(+) {id=12,slot_type=[blockItemList,kleene_plus__blockItemList_3]}
            |       |___aux_rule__declaration_3 {id=120,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=121,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=154,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=122,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=125,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:a {id=150,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=127,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=128,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=129,slot_type=Assign}
            |       |   |               |___Token:1 {id=147,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=123,slot_type=Semi}
            |       |___aux_rule__declaration_3 {id=84,slot_type=[aux_rule__blockItemList_2,declaration,aux_rule__declaration_3]}
            |       |   |___(+) {id=85,slot_type=declarationSpecifiers}
            |       |   |   |___Token:int {id=118,slot_type=[declarationSpecifier,typeSpecifierWithAttrList,typeSpecifier,Int]}
            |       |   |___(?) {id=86,slot_type=optional__declaration_2}
            |       |   |   |___initDeclarator {id=89,slot_type=[initDeclaratorList,initDeclarator]}
            |       |   |       |___Token:c {id=114,slot_type=[declarator,directDeclarator,aux_rule__directDeclarator_9,Identifier]}
            |       |   |       |___(?) {id=91,slot_type=optional__initDeclarator_2}
            |       |   |           |___aux_rule__initDeclarator_1 {id=92,slot_type=aux_rule__initDeclarator_1}
            |       |   |               |___Token:= {id=93,slot_type=Assign}
            |       |   |               |___Token:3 {id=111,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=87,slot_type=Semi}
            |       |___expressionStatement {id=17,slot_type=[aux_rule__blockItemList_2,statement,expressionStatement]}
            |           |___(?) {id=18,slot_type=optional__postfixExpression_1}
            |           |   |___postfixExpression {id=35,slot_type=[expression,assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression]}
            |           |       |___Token:printf {id=82,slot_type=[aux_rule__postfixExpression_4,Identifier]}
            |           |       |___(*) {id=37,slot_type=kleene_star__postfixExpression_2}
            |           |           |___aux_rule__postfixExpression_11 {id=39,slot_type=[aux_rule__postfixExpression_3,aux_rule__postfixExpression_11]}
            |           |               |___Token:( {id=40,slot_type=LeftParen}
            |           |               |___(?) {id=41,slot_type=optional__postfixExpression_1}
            |           |               |   |___expression {id=43,slot_type=expression}
            |           |               |       |___(+) {id=80,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=81,slot_type=StringLiteral}
            |           |               |       |___(*) {id=45,slot_type=kleene_star__expression_1}
            |           |               |           |___aux_rule__expression_2 {id=46,slot_type=aux_rule__expression_2}
            |           |               |               |___Token:, {id=47,slot_type=Comma}
            |           |               |               |___Token:c {id=64,slot_type=[assignmentExpression,conditionalExpression,logicalOrExpression,logicalAndExpression,inclusiveOrExpression,exclusiveOrExpression,andExpression,equalityExpression,relationalExpression,shiftExpression,additiveExpression,multiplicativeExpression,castExpression,unaryExpression,postfixExpression,aux_rule__postfixExpression_4,Identifier]}
            |           |               |___Token:) {id=42,slot_type=RightParen}
            |           |___Token:; {id=19,slot_type=Semi}
            |___Token:} {id=10,slot_type=RightBrace}
------------------------------------------------------------


==================Reducing node 2, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


==================Reducing node 4, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


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

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


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

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


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

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


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

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


==================Reducing node 7, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


==================Reducing node 9, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 12, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=12}
------------------------------------------------------------


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

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


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@2
    int main(    )
    {
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_plus:kleene_plus__blockItemList_3]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
    }
------------------------------------------------------------


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

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


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

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


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

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


=================Reducing node 17, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=17}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
                       ;
    }
------------------------------------------------------------


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

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


=================Reducing node 18, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
                       ;
    }
------------------------------------------------------------


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

Failed to reduce node 18
------------------------------------------------------------


=================Reducing node 35, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=35}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf         ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
               "%d"    ;
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
               "%d", c ;
    }
------------------------------------------------------------


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

Failed to reduce node 35
------------------------------------------------------------


=================Reducing node 120, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=120}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
                 ;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 120
------------------------------------------------------------


=================Reducing node 84, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=84}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
                 ;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 37, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__postfixExpression_2]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf         ;
    }
------------------------------------------------------------


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

Failed to reduce node 37
------------------------------------------------------------


=================Reducing node 39, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=39}
------------------------------------------------------------


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

Failed to reduce node 39
------------------------------------------------------------


=================Reducing node 155, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

Failed to reduce node 155
------------------------------------------------------------


=================Reducing node 122, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    int main(    )
    {
        int      ;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 125, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=125}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a    ;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 86, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__declaration_2]dd@1
    int main(    )
    {
        int a = 1;
        int      ;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 86
------------------------------------------------------------


=================Reducing node 89, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=89}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c    ;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 41, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__postfixExpression_1]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf(       );
    }
------------------------------------------------------------


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

Failed to reduce node 41
------------------------------------------------------------


=================Reducing node 43, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=43}
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

// edit action set type: [regular node]compatible replacement
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf(      c);
    }
------------------------------------------------------------


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

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


=================Reducing node 157, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 159, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=159}
------------------------------------------------------------


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

Failed to reduce node 159
------------------------------------------------------------


=================Reducing node 127, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

Failed to reduce node 127
------------------------------------------------------------


=================Reducing node 128, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=128}
------------------------------------------------------------


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

Failed to reduce node 128
------------------------------------------------------------


=================Reducing node 91, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:optional__initDeclarator_2]dd@1
    int main(    )
    {
        int a = 1;
        int c    ;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 92, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=92}
------------------------------------------------------------


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

Failed to reduce node 92
------------------------------------------------------------


=================Reducing node 45, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

// edit action set type: [kleene_star:kleene_star__expression_1]dd@1
    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d"   );
    }
------------------------------------------------------------


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

Failed to reduce node 45
------------------------------------------------------------


=================Reducing node 46, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 163, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 163
------------------------------------------------------------


=================Reducing node 162, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 162
------------------------------------------------------------


=================Reducing node 160, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 160
------------------------------------------------------------


=================Reducing node 150, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 147, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 129, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 129
------------------------------------------------------------


=================Reducing node 123, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 123
------------------------------------------------------------


=================Reducing node 121, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 154, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 114, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 114
------------------------------------------------------------


=================Reducing node 111, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 93, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 87, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 85, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 118, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 118
------------------------------------------------------------


=================Reducing node 82, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 80, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 81, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 81
------------------------------------------------------------


=================Reducing node 64, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 47, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 42, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 40, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 19, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


=================Reducing node 10, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


==================Reducing node 8, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


==================Reducing node 5, size=23==================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

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


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

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


=================Reducing node 164, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

    NodeDeletionAction{target_node=164}
------------------------------------------------------------


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

Failed to reduce node 164
------------------------------------------------------------


=================Reducing node 168, size=23=================

The current best program is the following

    int main(    )
    {
        int a = 1;
        int c = 3;
        printf("%d", c);
    }
------------------------------------------------------------


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

Failed to reduce node 168
------------------------------------------------------------


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