id stringlengths 26 66 | program stringlengths 37 1.08k | src-filename stringlengths 10 28 | semantics-type stringclasses 1 value | syntax stringclasses 1 value | semantics stringclasses 2 values | language stringclasses 1 value | mutated-program stringlengths 37 1.08k | mutated bool 1 class | mutation-pattern stringclasses 2 values | K-evaluatable bool 1 class | ground-truth stringlengths 200 1.67k | sampled-statements listlengths 3 10 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
srp-mk-K-addSub_mulDiv_negateRelation-add_digits.imp | int num;
int ans;
num = 38;
if((num % 9) == 0)
{
ans = 9;
}
else
{
ans = (num % 9);
}; | add_digits.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int num;
int ans;
num = 38;
if((num % 9) != 0)
{
ans = 9;
}
else
{
ans = (num % 9);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-adding_fractions.imp | int a;
int b;
int c;
int d;
int ans;
int f;
a = 1;
b = 1;
c = 13;
d = 19;
if(c == d)
{
ans = (a + b);
f = c;
}
else
{
ans = ((a * d) + (b * c));
f = (c * d);
}; | adding_fractions.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int c;
int d;
int ans;
int f;
a = 1;
b = 1;
c = 13;
d = 19;
if(c != d)
{
ans = (a - b);
f = c;
}
else
{
ans = ((a / d) - (b / c));
f = (c / d);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-addition.imp | int a;
int b;
int ans;
a = 3045;
b = 1078;
ans = (a + b); | addition.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int ans;
a = 3045;
b = 1078;
ans = (a - b); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-area_square.imp | int ans;
int a;
a = 156;
ans = (a * a); | area_square.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int a;
a = 156;
ans = (a / a); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-armstrong_num.imp | int x;
int p;
int q;
int r;
int m;
int k;
int j;
int ans;
x = 153;
q = x;
while(q > 0)
{
p = (p + 1);
q = (q / 10);
};
r = 0;
q = x;
while(x > 0)
{
m = (x % 10);
k = 1;
j = 0;
while(j < p)
{
k = (k * m);
j = (j + 1);
};
r = (r + k);
x = (x / 10);
};
if(r == q)
{
ans = 1;
}
else
{
}; | armstrong_num.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int x;
int p;
int q;
int r;
int m;
int k;
int j;
int ans;
x = 153;
q = x;
while(q < 0)
{
p = (p - 1);
q = (q * 10);
};
r = 0;
q = x;
while(x < 0)
{
m = (x % 10);
k = 1;
j = 0;
while(j > p)
{
k = (k / m);
j = (j - 1);
};
r = (r - k);
x = (x * 10);
};
if(r != q)
{
ans = 1;
}
else
{
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="9">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": 0,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-arrange_coins.imp | int X;
int ans;
int B;
X = 8;
B = 1;
if((X == 1) || (X == 2))
{
ans = 1;
halt;
}
else
{
};
while(X != 0)
{
if(X >= B)
{
X = (X - B);
ans = (ans + 1);
B = (B + 1);
}
else
{
break;
};
}; | arrange_coins.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int X;
int ans;
int B;
X = 8;
B = 1;
if((X != 1) && (X != 2))
{
ans = 1;
halt;
}
else
{
};
while(X == 0)
{
if(X <= B)
{
X = (X + B);
ans = (ans - 1);
B = (B - 1);
}
else
{
break;
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>16</rule>
<rule>1</rule>
<rule>16</rule>
<rule>20</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>17</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>15</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>1</rule>
<rule>15</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>21</rule>
<rule>23</rule>
<rule>33</rule>
<rule>33</rule>
<rule>35</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": 0,... | |
srp-mk-K-addSub_mulDiv_negateRelation-base_seven.imp | int n;
int m;
int num;
int ans;
n = 0;
m = 1;
num = (- 7);
while(num != 0)
{
n = (n + (m * (num % 7)));
num = (num / 7);
m = (m * 10);
};
ans = n; | base_seven.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int m;
int num;
int ans;
n = 0;
m = 1;
num = (+ 7);
while(num == 0)
{
n = (n - (m / (num % 7)));
num = (num * 7);
m = (m / 10);
};
ans = n; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>11</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>17</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>17</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": 0,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": 0,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-bulb_switch.imp | int i;
int ans;
int n;
i = 1;
n = 10;
while((i * i) <= n)
{
i = (i + 1);
ans = (ans + 1);
}; | bulb_switch.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int i;
int ans;
int n;
i = 1;
n = 10;
while((i / i) >= n)
{
i = (i - 1);
ans = (ans - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-bulb_switch_2.imp | int n;
int k;
int ans;
n = 3;
k = 1;
if(k == 0)
{
ans = 1;
halt;
}
else
{
};
if(n == 1)
{
ans = 2;
halt;
}
else
{
};
if((n == 2) && (k == 1))
{
ans = 3;
halt;
}
else
{
};
if((n == 2) || (k == 1))
{
ans = 4;
halt;
}
else
{
};
if(k == 2)
{
ans = 7;
halt;
}
else
{
};
ans = 8; | bulb_switch_2.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int k;
int ans;
n = 3;
k = 1;
if(k != 0)
{
ans = 1;
halt;
}
else
{
};
if(n != 1)
{
ans = 2;
halt;
}
else
{
};
if((n != 2) || (k != 1))
{
ans = 3;
halt;
}
else
{
};
if((n != 2) && (k != 1))
{
ans = 4;
halt;
}
else
{
};
if(k != 2)
{
ans = 7;
halt;
}
else
{
};
ans = 8; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>16</rule>
<rule>1</rule>
<rule>16</rule>
<rule>19</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>16</rule>
<rule>1</rule>
<rule>16</rule>
<rule>20</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>21</rule>
</answer>
<answer id="5">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-clumsy_fac.imp | int ans;
int s;
int i;
int n;
int t;
n = 10;
s = 1;
i = n;
while(i > 0)
{
t = i;
if((i - 1) > 0)
{
t = (t * (i - 1));
}
else
{
};
if((i - 2) > 0)
{
t = (t / (i - 2));
}
else
{
};
ans = (ans + (s * t));
if((i - 3) > 0)
{
ans = ((ans + i) - 3);
}
else
{
};
s = (- 1);
i = (i - 4);
}; | clumsy_fac.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int s;
int i;
int n;
int t;
n = 10;
s = 1;
i = n;
while(i < 0)
{
t = i;
if((i + 1) < 0)
{
t = (t / (i + 1));
}
else
{
};
if((i + 2) < 0)
{
t = (t * (i + 2));
}
else
{
};
ans = (ans - (s / t));
if((i + 3) < 0)
{
ans = ((ans - i) + 3);
}
else
{
};
s = (+ 1);
i = (i + 4);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>21</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="2">
<rule>11</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>4</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="9">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-codecontest_1581.imp | int t;
int n;
int m;
int k;
int s;
int first;
int tk;
int ans;
t = 5;
n = 4;
m = 5;
k = 3;
while(t > 0)
{
t = (t - 1);
s = (((n - 1) * n) / 2);
first = (n - 1);
if((m > s) || (m < first))
{
ans = 0;
continue;
}
else
{
};
if(m >= s)
{
tk = 1;
}
else
{
tk = 2;
};
if((n == 1) && (m == 0))
{
tk = 0;
}
else
{
};
if((k - 1) > tk)
{
ans = 1;
}
else
{
ans = 0;
};
}; | codecontest_1581.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int t;
int n;
int m;
int k;
int s;
int first;
int tk;
int ans;
t = 5;
n = 4;
m = 5;
k = 3;
while(t < 0)
{
t = (t + 1);
s = (((n + 1) / n) * 2);
first = (n + 1);
if((m < s) && (m > first))
{
ans = 0;
continue;
}
else
{
};
if(m <= s)
{
tk = 1;
}
else
{
tk = 2;
};
if((n != 1) || (m != 0))
{
tk = 0;
}
else
{
};
if((k + 1) < tk)
{
ans = 1;
}
else
{
ans = 0;
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>20</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>4</rule>
<rule>1</rule>
<rule>5</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>15</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>16</rule>
<rule>1</rule>
<rule>16</rule>
<rule>19</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>4</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="9">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": 0,
"m": 0,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-codecontest_1586.imp | int n;
int k;
int ans;
int x;
int y;
int i;
int j;
n = 5;
k = 3;
x = (n - 1);
while(x > 0)
{
x = (x / k);
ans = (ans + 1);
};
i = 1;
while(i < n)
{
j = (i + 1);
while(j <= n)
{
x = (i - 1);
y = (j - 1);
while(x != y)
{
x = (x / k);
y = (y / k);
ans = (ans + 1);
};
j = (j + 1);
};
i = (i + 1);
}; | codecontest_1586.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int k;
int ans;
int x;
int y;
int i;
int j;
n = 5;
k = 3;
x = (n + 1);
while(x < 0)
{
x = (x * k);
ans = (ans - 1);
};
i = 1;
while(i > n)
{
j = (i - 1);
while(j >= n)
{
x = (i + 1);
y = (j + 1);
while(x == y)
{
x = (x * k);
y = (y * k);
ans = (ans - 1);
};
j = (j - 1);
};
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="1">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="9">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": 4,
"j": 0,
"k": 3,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
"B... | |
srp-mk-K-addSub_mulDiv_negateRelation-codecontest_1594.imp | int T;
int ans;
int s;
int n;
int k;
T = 4;
s = 100;
n = 50;
k = 200;
while(T > 0)
{
T = (T - 1);
if(((k > s) || (((((n / k) * 2) * k) + (n % k)) <= s)) && (k != s))
{
ans = 0;
}
else
{
ans = 1;
};
}; | codecontest_1594.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int T;
int ans;
int s;
int n;
int k;
T = 4;
s = 100;
n = 50;
k = 200;
while(T < 0)
{
T = (T + 1);
if(((k < s) && (((((n * k) / 2) / k) - (n % k)) >= s)) || (k == s))
{
ans = 0;
}
else
{
ans = 1;
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>3</rule>
<rule>1</rule>
<rule>13</rule>
<rule>20</rule>
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-codecontest_1604_D.imp | int t;
int x;
int y;
int ans;
t = 1;
while(t > 0)
{
t = (t - 1);
x = 4;
y = 8;
if(x > y)
{
ans = (x + y);
continue;
}
else
{
};
ans = ((y + ((y / x) * x)) / 2);
}; | codecontest_1604_D.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int t;
int x;
int y;
int ans;
t = 1;
while(t < 0)
{
t = (t + 1);
x = 4;
y = 8;
if(x < y)
{
ans = (x - y);
continue;
}
else
{
};
ans = ((y - ((y * x) / x)) * 2);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-codecontest_1606_B.imp | int a;
int b;
int ans;
int c;
a = 8;
b = 3;
c = 1;
while(c < b)
{
c = (c * 2);
ans = (ans + 1);
};
if(c < a)
{
ans = ((((a - c) + b) - 1) / b);
}
else
{
}; | codecontest_1606_B.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int ans;
int c;
a = 8;
b = 3;
c = 1;
while(c > b)
{
c = (c / 2);
ans = (ans - 1);
};
if(c > a)
{
ans = ((((a + c) - b) + 1) * b);
}
else
{
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>1</rule>
<rule>3</rule>
<rule>4</rule>
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": 0,
"b": 0,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-codecontest_1607_B.imp | int n;
int ans;
ans = 10;
n = 99;
if((ans % 2) != 0)
{
if((n % 2) != 0)
{
if(((n / 2) % 2) != 0)
{
ans = ((ans - n) - 1);
}
else
{
ans = (ans + n);
};
}
else
{
if(((n / 2) % 2) != 0)
{
ans = (ans - 1);
}
else
{
};
};
}
else
{
if((n % 2) != 0)
{
if(((n / 2) % 2) != 0)
{
ans = ((ans + n) + 1);
}
else
{
ans = (ans - n);
};
}
else
{
if(((n / 2) % 2) != 0)
{
ans = (ans + 1);
}
else
{
};
};
}; | codecontest_1607_B.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int ans;
ans = 10;
n = 99;
if((ans % 2) == 0)
{
if((n % 2) == 0)
{
if(((n * 2) % 2) == 0)
{
ans = ((ans + n) + 1);
}
else
{
ans = (ans - n);
};
}
else
{
if(((n * 2) % 2) == 0)
{
ans = (ans + 1);
}
else
{
};
};
}
else
{
if((n % 2) == 0)
{
if(((n * 2) % 2) == 0)
{
ans = ((ans - n) - 1);
}
else
{
ans = (ans + n);
};
}
else
{
if(((n * 2) % 2) == 0)
{
ans = (ans - 1);
}
else
{
};
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>8</rule>
<rule>17</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>8</rule>
<rule>17</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>6</rule>
<rule>8</rule>
<rule>17</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-confusing_number.imp | int a;
int b;
int c;
int ans;
int d;
a = 89;
c = a;
while(a != 0)
{
d = (a % 10);
if(((((d == 2) || (d == 3)) || (d == 4)) || (d == 5)) || (d == 7))
{
ans = 0;
halt;
}
else
{
};
if(d == 6)
{
b = ((b * 10) + 9);
}
else
{
if(d == 9)
{
b = ((b * 10) + 6);
}
else
{
b = ((b * 10) + d);
};
};
a = (a / 10);
};
if(b != c)
{
ans = 1;
}
else
{
}; | confusing_number.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int c;
int ans;
int d;
a = 89;
c = a;
while(a == 0)
{
d = (a % 10);
if(((((d != 2) && (d != 3)) && (d != 4)) && (d != 5)) && (d != 7))
{
ans = 0;
halt;
}
else
{
};
if(d != 6)
{
b = ((b / 10) - 9);
}
else
{
if(d != 9)
{
b = ((b / 10) - 6);
}
else
{
b = ((b / 10) - d);
};
};
a = (a * 10);
};
if(b == c)
{
ans = 1;
}
else
{
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>16</rule>
<rule>1</rule>
<rule>16</rule>
<rule>20</rule>
<rule>1</rule>
<rule>16</rule>
<rule>20</rule>
<rule>1</rule>
<rule>16</rule>
<rule>20</rule>
<rule>1</rule>
<rule>16</rule>
<rule>20</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>17</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="9">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>17</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": 0,
"c": 0,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-divide_two_int.imp | int a;
int b;
int aa;
int bb;
int tmp;
int m;
int ans;
a = 10;
b = 3;
if(a < 0)
{
aa = ((- 1) * a);
}
else
{
aa = a;
};
if(b < 0)
{
bb = ((- 1) * b);
}
else
{
bb = b;
};
while(bb <= aa)
{
m = bb;
tmp = 1;
while(m <= (aa - m))
{
m = (m + m);
tmp = (tmp + tmp);
};
ans = (ans + tmp);
aa = (aa - m);
};
if((((a < 0) && (b > 0)) || (a > 0)) && (b < 0))
{
ans = (ans * (- 1));
}
else
{
}; | divide_two_int.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int aa;
int bb;
int tmp;
int m;
int ans;
a = 10;
b = 3;
if(a > 0)
{
aa = ((+ 1) / a);
}
else
{
aa = a;
};
if(b > 0)
{
bb = ((+ 1) / b);
}
else
{
bb = b;
};
while(bb >= aa)
{
m = bb;
tmp = 1;
while(m >= (aa + m))
{
m = (m - m);
tmp = (tmp - tmp);
};
ans = (ans - tmp);
aa = (aa + m);
};
if((((a > 0) || (b < 0)) && (a < 0)) || (b > 0))
{
ans = (ans / (+ 1));
}
else
{
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>21</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="8">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="9">
<rule>1</rule>
<rule>12</rule>
<rule>1</rule>
<rule>14</rule>
<rule>19</rule>
<rule>1</rule>
<rule>14</rule>
<rule>20</rule>
<rule>1</rule>
<rule>12</rule>
<rule>19</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": 0,
"b": 0,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": 0,
"p": null,
"q": null,
"r": null,
"X": null,
"B... | |
srp-mk-K-addSub_mulDiv_negateRelation-elimination_game.imp | int f;
int c;
int x;
int ans;
ans = 9;
c = 1;
x = ans;
while(x > 1)
{
if(f == 0)
{
if((x % 2) == 1)
{
ans = (ans - c);
}
else
{
};
}
else
{
ans = (ans - c);
};
x = (x / 2);
c = (c * 2);
f = (1 - f);
}; | elimination_game.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int f;
int c;
int x;
int ans;
ans = 9;
c = 1;
x = ans;
while(x < 1)
{
if(f != 0)
{
if((x % 2) != 1)
{
ans = (ans + c);
}
else
{
};
}
else
{
ans = (ans + c);
};
x = (x * 2);
c = (c / 2);
f = (1 + f);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="9">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": 0,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-factorial.imp | int n;
int i;
int ans;
n = 6;
i = 1;
ans = 1;
while(i <= n)
{
ans = (ans * i);
i = (i + 1);
}; | factorial.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int i;
int ans;
n = 6;
i = 1;
ans = 1;
while(i >= n)
{
ans = (ans / i);
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-factorial_trailing_zeros.imp | int ans;
int n;
int s;
n = 5;
s = 1;
while(n > 0)
{
n = (n / 5);
ans = (ans + n);
}; | factorial_trailing_zeros.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
int s;
n = 5;
s = 1;
while(n < 0)
{
n = (n * 5);
ans = (ans - n);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-fibonacci.imp | int n;
int a;
int b;
int i;
int ans;
n = 6;
a = 1;
b = 1;
i = 3;
if((n == 1) || (n == 2))
{
ans = 1;
}
else
{
while(i <= n)
{
ans = (a + b);
b = a;
a = ans;
i = (i + 1);
};
}; | fibonacci.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int a;
int b;
int i;
int ans;
n = 6;
a = 1;
b = 1;
i = 3;
if((n != 1) && (n != 2))
{
ans = 1;
}
else
{
while(i >= n)
{
ans = (a - b);
b = a;
a = ans;
i = (i - 1);
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>16</rule>
<rule>1</rule>
<rule>16</rule>
<rule>20</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-gross_salary.imp | int a;
int b;
int d;
int ans;
d = 100;
a = 20;
b = 20;
ans = ((b + a) * (1 + (d / 100))); | gross_salary.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int d;
int ans;
d = 100;
a = 20;
b = 20;
ans = ((b - a) / (1 - (d * 100))); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>1</rule>
<rule>6</rule>
<rule>3</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_102.imp | int ans;
int x;
int y;
x = 12;
y = 15;
if(y < x)
{
ans = (- 1);
halt;
}
else
{
};
if((y == x) && ((y % 2) == 1))
{
ans = (- 1);
halt;
}
else
{
};
if((y % 2) == 1)
{
ans = (y - 1);
halt;
}
else
{
};
ans = y; | humaneval_102.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int x;
int y;
x = 12;
y = 15;
if(y > x)
{
ans = (+ 1);
halt;
}
else
{
};
if((y != x) || ((y % 2) != 1))
{
ans = (+ 1);
halt;
}
else
{
};
if((y % 2) != 1)
{
ans = (y + 1);
halt;
}
else
{
};
ans = y; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>19</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_13.imp | int a;
int b;
int ans;
int m;
a = 10;
b = 15;
while(true)
{
if(a < b)
{
m = a;
a = b;
b = m;
}
else
{
};
a = (a % b);
if(a == 0)
{
ans = b;
halt;
}
else
{
};
}; | humaneval_13.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int ans;
int m;
a = 10;
b = 15;
while(true)
{
if(a > b)
{
m = a;
a = b;
b = m;
}
else
{
};
a = (a % b);
if(a != 0)
{
ans = b;
halt;
}
else
{
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_138.imp | int ans;
int n;
n = 8;
if(((n % 2) == 0) && (n >= 8))
{
ans = 1;
halt;
}
else
{
};
ans = 0; | humaneval_138.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
n = 8;
if(((n % 2) != 0) || (n <= 8))
{
ans = 1;
halt;
}
else
{
};
ans = 0; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>15</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_139.imp | int xyz;
int ans;
int p;
int q;
p = 5;
xyz = 1;
ans = 1;
q = 1;
while(q <= p)
{
xyz = (xyz * q);
ans = (ans * xyz);
q = (q + 1);
};
ans = ans; | humaneval_139.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int xyz;
int ans;
int p;
int q;
p = 5;
xyz = 1;
ans = 1;
q = 1;
while(q >= p)
{
xyz = (xyz / q);
ans = (ans / xyz);
q = (q - 1);
};
ans = ans; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": 0,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_24.imp | int ans;
int i;
int n;
i = 2;
n = 10;
while((i * i) <= n)
{
if((n % i) == 0)
{
ans = (n / i);
halt;
}
else
{
};
i = (i + 1);
};
ans = 1; | humaneval_24.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int n;
i = 2;
n = 10;
while((i / i) >= n)
{
if((n % i) != 0)
{
ans = (n * i);
halt;
}
else
{
};
i = (i - 1);
};
ans = 1; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_31.imp | int ans;
int n;
int i;
n = 61;
if(n < 2)
{
ans = 0;
halt;
}
else
{
};
i = 2;
while((i * i) <= n)
{
if((n % i) == 0)
{
ans = 1;
halt;
}
else
{
};
i = (i + 1);
};
ans = 1; | humaneval_31.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
int i;
n = 61;
if(n > 2)
{
ans = 0;
halt;
}
else
{
};
i = 2;
while((i / i) >= n)
{
if((n % i) != 0)
{
ans = 1;
halt;
}
else
{
};
i = (i - 1);
};
ans = 1; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_36.imp | int ans;
int i;
int n;
int q;
ans = 0;
i = 0;
n = 100;
while(i < n)
{
if(((i % 11) == 0) || ((i % 13) == 0))
{
q = i;
while(q > 0)
{
if((q % 10) == 7)
{
ans = (ans + 1);
}
else
{
};
q = (q / 10);
};
}
else
{
};
i = (i + 1);
}; | humaneval_36.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int n;
int q;
ans = 0;
i = 0;
n = 100;
while(i > n)
{
if(((i % 11) != 0) && ((i % 13) != 0))
{
q = i;
while(q < 0)
{
if((q % 10) != 7)
{
ans = (ans - 1);
}
else
{
};
q = (q * 10);
};
}
else
{
};
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>20</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>20</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="9">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_39.imp | int x;
int y;
int a;
int b;
int c;
int d;
int ans;
int e;
x = 1;
y = 2;
e = 5;
d = 0;
while(d < e)
{
x = (x + y);
a = x;
x = y;
y = a;
b = 1;
c = 2;
while((c * c) <= x)
{
if((x % c) == 0)
{
b = 0;
}
else
{
};
c = (c + 1);
};
if(b == 1)
{
d = (d + 1);
}
else
{
};
if(d == e)
{
ans = x;
halt;
}
else
{
};
}; | humaneval_39.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int x;
int y;
int a;
int b;
int c;
int d;
int ans;
int e;
x = 1;
y = 2;
e = 5;
d = 0;
while(d > e)
{
x = (x - y);
a = x;
x = y;
y = a;
b = 1;
c = 2;
while((c / c) >= x)
{
if((x % c) != 0)
{
b = 0;
}
else
{
};
c = (c - 1);
};
if(b != 1)
{
d = (d - 1);
}
else
{
};
if(d != e)
{
ans = x;
halt;
}
else
{
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="9">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": 0,
"c": 0,
"d": null,
"f": null,
"x": 0,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
"B... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_41.imp | int ans;
int n;
n = 4;
ans = (n * n); | humaneval_41.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
n = 4;
ans = (n / n); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_49.imp | int ans;
int n;
int p;
int i;
n = 3;
p = 11;
ans = 1;
i = 0;
while(i < n)
{
ans = (ans * 2);
ans = (ans % p);
i = (i + 1);
}; | humaneval_49.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
int p;
int i;
n = 3;
p = 11;
ans = 1;
i = 0;
while(i > n)
{
ans = (ans / 2);
ans = (ans % p);
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_59.imp | int ans;
int n;
int i;
n = 13195;
i = 2;
while((i * i) <= n)
{
while(((n % i) == 0) && (n > i))
{
n = (n / i);
};
i = (i + 1);
};
ans = n; | humaneval_59.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
int i;
n = 13195;
i = 2;
while((i / i) >= n)
{
while(((n % i) != 0) || (n < i))
{
n = (n * i);
};
i = (i - 1);
};
ans = n; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>19</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_60.imp | int ans;
int n;
n = 30;
ans = ((n * (n + 1)) / 2); | humaneval_60.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
n = 30;
ans = ((n / (n - 1)) * 2); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>5</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_75.imp | int num;
int ans;
int a;
int i;
num = 0;
a = 125;
i = 2;
while((i * i) <= a)
{
while(((a % i) == 0) && (a > i))
{
a = (a / i);
num = (num + 1);
};
i = (i + 1);
};
if(num == 2)
{
ans = 1;
halt;
}
else
{
};
ans = 0; | humaneval_75.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int num;
int ans;
int a;
int i;
num = 0;
a = 125;
i = 2;
while((i / i) >= a)
{
while(((a % i) != 0) || (a < i))
{
a = (a * i);
num = (num - 1);
};
i = (i - 1);
};
if(num != 2)
{
ans = 1;
halt;
}
else
{
};
ans = 0; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>19</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="9">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": 0,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_76.imp | int a;
int b;
int ans;
int c;
int d;
a = 1;
b = 0;
c = 8;
d = 2;
while((a <= c) && (b < 100))
{
if(a == c)
{
ans = 1;
halt;
}
else
{
};
a = (a * d);
b = (b + 1);
};
ans = 0; | humaneval_76.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int ans;
int c;
int d;
a = 1;
b = 0;
c = 8;
d = 2;
while((a >= c) || (b > 100))
{
if(a != c)
{
ans = 1;
halt;
}
else
{
};
a = (a / d);
b = (b - 1);
};
ans = 0; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>1</rule>
<rule>12</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-humaneval_83.imp | int ans;
int n;
int i;
n = 3;
if(n < 1)
{
ans = 0;
halt;
}
else
{
};
if(n == 1)
{
ans = 1;
halt;
}
else
{
};
ans = 18;
i = 2;
while(i < n)
{
ans = (ans * 10);
i = (i + 1);
}; | humaneval_83.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
int i;
n = 3;
if(n > 1)
{
ans = 0;
halt;
}
else
{
};
if(n != 1)
{
ans = 1;
halt;
}
else
{
};
ans = 18;
i = 2;
while(i > n)
{
ans = (ans / 10);
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-int_break.imp | int n;
int a;
int b;
int c;
int ans;
n = 10;
a = (n / 3);
b = (n % 3);
if(b == 1)
{
a = (a - 1);
b = 4;
}
else
{
if(b == 0)
{
b = 1;
}
else
{
};
};
ans = 1;
while(a > 0)
{
ans = (ans * 3);
a = (a - 1);
};
ans = (ans * b); | int_break.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int a;
int b;
int c;
int ans;
n = 10;
a = (n * 3);
b = (n % 3);
if(b != 1)
{
a = (a + 1);
b = 4;
}
else
{
if(b != 0)
{
b = 1;
}
else
{
};
};
ans = 1;
while(a < 0)
{
ans = (ans / 3);
a = (a + 1);
};
ans = (ans / b); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="9">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": 0,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_112.imp | int ans;
int x;
int y;
x = 2;
y = 4;
ans = (2 * (y + x)); | mbpp_112.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int x;
int y;
x = 2;
y = 4;
ans = (2 / (y - x)); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_123.imp | int a;
int b;
int c;
int d;
int e;
int ans;
int f;
f = 10;
b = 2;
while(b <= f)
{
c = 0;
e = 1;
while(e < b)
{
if((b % e) == 0)
{
c = (c + e);
}
else
{
};
e = (e + 1);
};
d = 0;
e = 1;
while(e < c)
{
if((c % e) == 0)
{
d = (d + e);
}
else
{
};
e = (e + 1);
};
if(((b == d) && (b != c)) && (c != 0))
{
a = (a + b);
}
else
{
};
b = (b + 1);
};
ans = a; | mbpp_123.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int c;
int d;
int e;
int ans;
int f;
f = 10;
b = 2;
while(b >= f)
{
c = 0;
e = 1;
while(e > b)
{
if((b % e) != 0)
{
c = (c - e);
}
else
{
};
e = (e - 1);
};
d = 0;
e = 1;
while(e > c)
{
if((c % e) != 0)
{
d = (d - e);
}
else
{
};
e = (e - 1);
};
if(((b != d) || (b == c)) || (c == 0))
{
a = (a - b);
}
else
{
};
b = (b - 1);
};
ans = a; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="9">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": 0,
"c": 0,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_126.imp | int i;
int ans;
int a;
int b;
i = 1;
a = 10;
b = 15;
while((i <= a) && (i <= b))
{
if(((a % i) == 0) && ((b % i) == 0))
{
ans = (ans + i);
}
else
{
};
i = (i + 1);
}; | mbpp_126.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int i;
int ans;
int a;
int b;
i = 1;
a = 10;
b = 15;
while((i >= a) || (i >= b))
{
if(((a % i) != 0) || ((b % i) != 0))
{
ans = (ans - i);
}
else
{
};
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>19</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>19</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": 0,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_14.imp | int ans;
int l;
int b;
int h;
l = 10;
b = 8;
h = 6;
ans = (((l * b) * h) / 2); | mbpp_14.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int l;
int b;
int h;
l = 10;
b = 8;
h = 6;
ans = (((l / b) / h) * 2); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_148.imp | int a;
int b;
int ans;
int x;
int y;
y = 35;
x = y;
while(x > 0)
{
a = (a + (x % 10));
x = (x / 10);
};
x = (y - a);
while(x > 0)
{
b = (b + (x % 10));
x = (x / 10);
};
ans = (a + b); | mbpp_148.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int ans;
int x;
int y;
y = 35;
x = y;
while(x < 0)
{
a = (a - (x % 10));
x = (x * 10);
};
x = (y + a);
while(x < 0)
{
b = (b - (x % 10));
x = (x * 10);
};
ans = (a - b); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": 0,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_162.imp | int i;
int ans;
int n;
n = 6;
i = n;
while(i > 0)
{
ans = (ans + i);
i = (i - 2);
}; | mbpp_162.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int i;
int ans;
int n;
n = 6;
i = n;
while(i < 0)
{
ans = (ans - i);
i = (i + 2);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_164.imp | int a;
int b;
int c;
int d;
int ans;
int e;
int f;
e = 36;
f = 57;
a = e;
b = f;
c = 2;
d = 0;
while(c <= ((a + b) / 2))
{
if(((a % c) == 0) && ((b % c) == 0))
{
d = (d + 1);
}
else
{
};
c = (c + 1);
};
if(d == 0)
{
ans = 1;
}
else
{
ans = 0;
}; | mbpp_164.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int c;
int d;
int ans;
int e;
int f;
e = 36;
f = 57;
a = e;
b = f;
c = 2;
d = 0;
while(c >= ((a - b) * 2))
{
if(((a % c) != 0) || ((b % c) != 0))
{
d = (d - 1);
}
else
{
};
c = (c - 1);
};
if(d != 0)
{
ans = 1;
}
else
{
ans = 0;
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>6</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>19</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>6</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": 0,
"c": 0,
"d": 0,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
"B... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_17.imp | int ans;
int a;
a = 10;
ans = (4 * a); | mbpp_17.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int a;
a = 10;
ans = (4 / a); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_190.imp | int x1;
int x2;
int y1;
int y2;
int ans;
int count;
int i;
int j;
x1 = 4;
x2 = 6;
y1 = 2;
y2 = 4;
count = 0;
if((x1 == x2) && (y1 == y2))
{
ans = 1;
halt;
}
else
{
};
i = x1;
while(i < x2)
{
j = y1;
while(j < y2)
{
if((i != x1) && (j != y1))
{
count = (count + 1);
}
else
{
};
j = (j + 1);
};
i = (i + 1);
};
ans = count; | mbpp_190.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int x1;
int x2;
int y1;
int y2;
int ans;
int count;
int i;
int j;
x1 = 4;
x2 = 6;
y1 = 2;
y2 = 4;
count = 0;
if((x1 != x2) || (y1 != y2))
{
ans = 1;
halt;
}
else
{
};
i = x1;
while(i > x2)
{
j = y1;
while(j > y2)
{
if((i == x1) || (j == y1))
{
count = (count - 1);
}
else
{
};
j = (j - 1);
};
i = (i - 1);
};
ans = count; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>19</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="8">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_199.imp | int i;
int ans;
int n;
i = 1;
n = 10;
while(n > 1)
{
i = (i * 2);
n = (n / 2);
};
ans = i; | mbpp_199.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int i;
int ans;
int n;
i = 1;
n = 10;
while(n < 1)
{
i = (i / 2);
n = (n * 2);
};
ans = i; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_2.imp | int ans;
int i;
int n;
n = 13;
if(n == 2)
{
ans = 3;
halt;
}
else
{
};
if(n == 8)
{
ans = 153;
halt;
}
else
{
};
if(n == 12)
{
ans = 2131;
halt;
}
else
{
};
i = 2;
while(i < n)
{
if((n % i) == 0)
{
ans = i;
halt;
}
else
{
};
i = (i + 1);
};
ans = (n - 1); | mbpp_2.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int n;
n = 13;
if(n != 2)
{
ans = 3;
halt;
}
else
{
};
if(n != 8)
{
ans = 153;
halt;
}
else
{
};
if(n != 12)
{
ans = 2131;
halt;
}
else
{
};
i = 2;
while(i > n)
{
if((n % i) != 0)
{
ans = i;
halt;
}
else
{
};
i = (i - 1);
};
ans = (n + 1); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="2">
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_20.imp | int ans;
int x;
int p;
x = 383;
if((x % 2) == 0)
{
ans = 0;
halt;
}
else
{
};
if(x == 1)
{
ans = 1;
halt;
}
else
{
};
x = (x + 1);
p = 0;
while((x % 2) == 0)
{
ans = x;
x = (x / 2);
p = (p + 1);
if(p == x)
{
ans = 1;
halt;
}
else
{
};
};
ans = 2; | mbpp_20.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int x;
int p;
x = 383;
if((x % 2) != 0)
{
ans = 0;
halt;
}
else
{
};
if(x != 1)
{
ans = 1;
halt;
}
else
{
};
x = (x - 1);
p = 0;
while((x % 2) != 0)
{
ans = x;
x = (x * 2);
p = (p - 1);
if(p != x)
{
ans = 1;
halt;
}
else
{
};
};
ans = 2; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="8">
<rule>21</rule>
</answer>
<answer id="9">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": 0,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_211.imp | int count;
int i;
int ans;
int n;
count = 0;
i = 0;
n = 3;
while(i < n)
{
if((i % 2) == 0)
{
count = (count + 1);
}
else
{
};
i = (i + 1);
};
ans = count; | mbpp_211.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int count;
int i;
int ans;
int n;
count = 0;
i = 0;
n = 3;
while(i > n)
{
if((i % 2) != 0)
{
count = (count - 1);
}
else
{
};
i = (i - 1);
};
ans = count; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_227.imp | int ans;
int a;
int b;
int c;
a = (- 10);
b = (- 20);
c = (- 30);
if(a < b)
{
if(a < c)
{
ans = a;
halt;
}
else
{
ans = c;
halt;
};
}
else
{
if(b < c)
{
ans = b;
halt;
}
else
{
ans = c;
halt;
};
}; | mbpp_227.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int a;
int b;
int c;
a = (+ 10);
b = (+ 20);
c = (+ 30);
if(a > b)
{
if(a > c)
{
ans = a;
halt;
}
else
{
ans = c;
halt;
};
}
else
{
if(b > c)
{
ans = b;
halt;
}
else
{
ans = c;
halt;
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>11</rule>
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_228.imp | int sum;
int i;
int j;
int n;
int l;
int r;
int ans;
n = 39;
l = 4;
r = 6;
while(i < n)
{
j = 0;
while(j < l)
{
if(((((i != j) && (i != 0)) && (j != 0)) && (i != 1)) && (j != 1))
{
sum = (sum + ((((i - 1) * (j - 1)) * (i - 1)) * (j - 1)));
}
else
{
};
j = (j + 1);
};
i = (i + 1);
};
if(sum == 0)
{
ans = 1;
}
else
{
}; | mbpp_228.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int sum;
int i;
int j;
int n;
int l;
int r;
int ans;
n = 39;
l = 4;
r = 6;
while(i > n)
{
j = 0;
while(j > l)
{
if(((((i == j) || (i == 0)) || (j == 0)) || (i == 1)) || (j == 1))
{
sum = (sum - ((((i + 1) / (j + 1)) / (i + 1)) / (j + 1)));
}
else
{
};
j = (j - 1);
};
i = (i - 1);
};
if(sum != 0)
{
ans = 1;
}
else
{
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>1</rule>
<rule>4</rule>
<rule>5</rule>
<rule>1</rule>
<rule>4</rule>
<rule>5</rule>
<rule>1</rule>
<rule>4</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>21</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": 0,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_236.imp | int a;
int b;
int ans;
int n;
int k;
n = 4;
k = 2;
if(n < k)
{
ans = (- 1);
halt;
}
else
{
a = ((((n - k) + 1) * ((n - k) + 2)) / 2);
b = ((((n - (2 * k)) + 1) * ((n - (2 * k)) + 2)) / 2);
ans = (a + b);
}; | mbpp_236.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int ans;
int n;
int k;
n = 4;
k = 2;
if(n > k)
{
ans = (+ 1);
halt;
}
else
{
a = ((((n + k) - 1) / ((n + k) - 2)) * 2);
b = ((((n + (2 / k)) - 1) / ((n + (2 / k)) - 2)) * 2);
ans = (a - b);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>3</rule>
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>3</rule>
<rule>5</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>4</rule>
<rule>3</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>4</rule>
<rule>3</rule>
<rule>5</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_24.imp | int ans;
int x7f;
int k9m;
int p2d;
x7f = 1;
ans = 0;
k9m = 1101101;
p2d = 0;
while(k9m > 0)
{
p2d = (p2d + ((k9m % 10) * x7f));
x7f = (x7f * 2);
k9m = (k9m / 10);
};
ans = p2d; | mbpp_24.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int x7f;
int k9m;
int p2d;
x7f = 1;
ans = 0;
k9m = 1101101;
p2d = 0;
while(k9m < 0)
{
p2d = (p2d - ((k9m % 10) / x7f));
x7f = (x7f / 2);
k9m = (k9m * 10);
};
ans = p2d; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_244.imp | int ans;
int n;
int m;
n = 35;
if(n <= 3)
{
ans = 4;
halt;
}
else
{
};
m = 2;
while((m * m) <= n)
{
m = (m + 1);
};
ans = (m * m); | mbpp_244.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
int m;
n = 35;
if(n >= 3)
{
ans = 4;
halt;
}
else
{
};
m = 2;
while((m / m) >= n)
{
m = (m - 1);
};
ans = (m / m); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="2">
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_271.imp | int ans;
int i;
int n;
int j;
i = 1;
n = 3;
while(i <= n)
{
j = (2 * i);
ans = (ans + ((((j * j) * j) * j) * j));
i = (i + 1);
}; | mbpp_271.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int n;
int j;
i = 1;
n = 3;
while(i >= n)
{
j = (2 / i);
ans = (ans - ((((j / j) / j) / j) / j));
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_283.imp | int cnt;
int ans;
int n;
n = 51241;
while(n > 0)
{
cnt = (cnt + (n % 10));
n = (n / 10);
};
if((cnt % 2) == 0)
{
ans = 1;
}
else
{
}; | mbpp_283.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int cnt;
int ans;
int n;
n = 51241;
while(n < 0)
{
cnt = (cnt - (n % 10));
n = (n * 10);
};
if((cnt % 2) != 0)
{
ans = 1;
}
else
{
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_295.imp | int ans;
int i;
int n;
i = 1;
n = 12;
while(i < n)
{
if((n % i) == 0)
{
ans = (ans + i);
}
else
{
};
i = (i + 1);
}; | mbpp_295.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int n;
i = 1;
n = 12;
while(i > n)
{
if((n % i) != 0)
{
ans = (ans - i);
}
else
{
};
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_318.imp | int ans;
int i;
int s;
int k;
int j;
int vol;
s = 8;
i = 1;
while(i <= s)
{
j = 1;
while(j <= s)
{
k = 1;
while(k <= s)
{
if(((i + j) + k) > s)
{
k = (k + 1);
continue;
}
else
{
};
vol = ((i * j) * k);
if(vol > ans)
{
ans = vol;
}
else
{
};
k = (k + 1);
};
j = (j + 1);
};
i = (i + 1);
}; | mbpp_318.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int s;
int k;
int j;
int vol;
s = 8;
i = 1;
while(i >= s)
{
j = 1;
while(j >= s)
{
k = 1;
while(k >= s)
{
if(((i - j) - k) < s)
{
k = (k - 1);
continue;
}
else
{
};
vol = ((i / j) / k);
if(vol < ans)
{
ans = vol;
}
else
{
};
k = (k - 1);
};
j = (j - 1);
};
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="1">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>1</rule>
<rule>3</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>1</rule>
<rule>3</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="8">
<rule>21</rule>
</answer>
<answer id="9">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>21</rule>
<rule>22</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
<rule>30</rule>
<rule>30</rule>
<rule>30</rule>
<rule>29</rule>
<rule>25</rule>
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": 1,
"k": 1,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_32.imp | int x;
int p;
int ans;
int k;
p = 2;
x = 3;
k = 15;
while(x < k)
{
if((k % x) == 0)
{
if(x > p)
{
p = x;
}
else
{
};
}
else
{
};
x = (x + 1);
};
ans = p; | mbpp_32.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int x;
int p;
int ans;
int k;
p = 2;
x = 3;
k = 15;
while(x > k)
{
if((k % x) != 0)
{
if(x < p)
{
p = x;
}
else
{
};
}
else
{
};
x = (x - 1);
};
ans = p; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_320.imp | int a;
int b;
int n;
int ans;
int i;
int j;
n = 12;
i = 1;
while(i <= n)
{
a = (a + i);
i = (i + 1);
};
j = 1;
while(j <= n)
{
b = (b + (j * j));
j = (j + 1);
};
ans = ((a * a) - b); | mbpp_320.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int a;
int b;
int n;
int ans;
int i;
int j;
n = 12;
i = 1;
while(i >= n)
{
a = (a - i);
i = (i - 1);
};
j = 1;
while(j >= n)
{
b = (b - (j / j));
j = (j - 1);
};
ans = ((a / a) + b); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": 0,
"b": 0,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_327.imp | int ans;
int x;
int y;
int z;
x = 6;
y = 16;
z = 20;
if(((x != y) || ((z != z) && (x != x))) || ((y != z) && (y != y)))
{
halt;
}
else
{
};
ans = 1; | mbpp_327.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int x;
int y;
int z;
x = 6;
y = 16;
z = 20;
if(((x == y) && ((z == z) || (x == x))) && ((y == z) || (y == y)))
{
halt;
}
else
{
};
ans = 1; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>20</rule>
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>1</rule>
<rule>1</rule>
<rule>17</rule>
<rule>19</rule>
<rule>20</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": 0,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_334.imp | int ans;
int a;
int b;
int c;
a = 7;
b = 10;
c = 5;
if((((a + b) > c) && ((b + c) > a)) && ((a + c) > b))
{
ans = 1;
}
else
{
}; | mbpp_334.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int a;
int b;
int c;
a = 7;
b = 10;
c = 5;
if((((a - b) < c) || ((b - c) < a)) || ((a - c) < b))
{
ans = 1;
}
else
{
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>1</rule>
<rule>14</rule>
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>1</rule>
<rule>14</rule>
<rule>19</rule>
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>1</rule>
<rule>14</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_339.imp | int ans;
int x;
int y;
int i;
x = 5;
y = 10;
if(x == y)
{
ans = x;
halt;
}
else
{
i = 1;
while(((x % i) == 0) && ((y % i) == 0))
{
i = (i + 1);
};
ans = i;
}; | mbpp_339.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int x;
int y;
int i;
x = 5;
y = 10;
if(x != y)
{
ans = x;
halt;
}
else
{
i = 1;
while(((x % i) != 0) || ((y % i) != 0))
{
i = (i - 1);
};
ans = i;
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>19</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_346.imp | int ans;
int n;
int k;
n = 4;
k = 3;
while(n > 0)
{
if(k == 0)
{
halt;
}
else
{
};
k = (k - 1);
if((n % 2) != 0)
{
n = (n + 1);
ans = (ans + 1);
}
else
{
n = (n / 2);
ans = (ans + 2);
};
}; | mbpp_346.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
int k;
n = 4;
k = 3;
while(n < 0)
{
if(k != 0)
{
halt;
}
else
{
};
k = (k + 1);
if((n % 2) == 0)
{
n = (n - 1);
ans = (ans - 1);
}
else
{
n = (n * 2);
ans = (ans - 2);
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>21</rule>
</answer>
<answer id="1">
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>8</rule>
<rule>17</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>8</rule>
<rule>17</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="9">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": 0,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_35.imp | int ans;
int n;
n = 6;
ans = (n * (n + 1)); | mbpp_35.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
n = 6;
ans = (n / (n - 1)); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_354.imp | int ans;
int i;
int a;
int d;
int n;
a = 2;
n = 6;
d = 4;
while(i < n)
{
ans = (a + (i * d));
i = (i + 1);
}; | mbpp_354.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int a;
int d;
int n;
a = 2;
n = 6;
d = 4;
while(i > n)
{
ans = (a - (i / d));
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": 0,
"b": null,
"c": null,
"d": 0,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_355.imp | int ans;
int x;
int y;
y = 2;
while(x < ((y * y) * y))
{
ans = (ans + 1);
x = (x + 1);
}; | mbpp_355.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int x;
int y;
y = 2;
while(x > ((y / y) / y))
{
ans = (ans - 1);
x = (x - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": 0,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_356.imp | int ans;
int a;
int b;
a = 45;
b = 95;
ans = ((a + b) % 180);
if(ans > 90)
{
ans = (180 - ans);
}
else
{
}; | mbpp_356.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int a;
int b;
a = 45;
b = 95;
ans = ((a - b) % 180);
if(ans < 90)
{
ans = (180 + ans);
}
else
{
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_36.imp | int x;
int ans;
int k;
int m;
int i;
x = 0;
k = 5;
m = 6;
i = 5;
while(i > 0)
{
i = (i - 1);
k = (k * 10);
x = (k / m);
k = (k % m);
};
ans = x; | mbpp_36.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int x;
int ans;
int k;
int m;
int i;
x = 0;
k = 5;
m = 6;
i = 5;
while(i < 0)
{
i = (i + 1);
k = (k / 10);
x = (k * m);
k = (k % m);
};
ans = x; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": 0,
"j": null,
"k": 0,
"m": 0,
"p": null,
"q": null,
"r": null,
"X": null,
"B... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_365.imp | int ans;
int n;
n = 11223305;
while(n > 0)
{
n = (n / 10);
ans = (ans + 1);
}; | mbpp_365.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
n = 11223305;
while(n < 0)
{
n = (n * 10);
ans = (ans - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_375.imp | int i;
int ans;
int n;
int m;
n = 1111;
m = 5;
while(i < m)
{
ans = (ans + (n / m));
i = (i + 1);
}; | mbpp_375.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int i;
int ans;
int n;
int m;
n = 1111;
m = 5;
while(i > m)
{
ans = (ans - (n * m));
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_402.imp | int ans;
int i;
int r;
int p;
int n;
n = 15;
r = 12;
p = 43;
ans = 1;
i = 1;
while(i <= r)
{
ans = ((ans * ((n - i) + 1)) / i);
i = (i + 1);
};
ans = (ans % p); | mbpp_402.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int r;
int p;
int n;
n = 15;
r = 12;
p = 43;
ans = 1;
i = 1;
while(i >= r)
{
ans = ((ans / ((n + i) - 1)) * i);
i = (i - 1);
};
ans = (ans % p); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>3</rule>
<rule>5</rule>
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": 0,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_420.imp | int n;
int ans;
int i;
n = 4;
i = 1;
while(i <= n)
{
ans = (ans + (((2 * i) * (2 * i)) * (2 * i)));
i = (i + 1);
}; | mbpp_420.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int ans;
int i;
n = 4;
i = 1;
while(i >= n)
{
ans = (ans - (((2 / i) / (2 / i)) / (2 / i)));
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_430.imp | int ans;
int a;
int b;
int c;
int x;
int y;
a = 5;
b = 3;
c = 2;
x = (b - a);
y = (c - b);
if(x > y)
{
ans = (- 2336);
halt;
}
else
{
if(x < y)
{
ans = (- 198);
}
else
{
ans = (- 130);
};
}; | mbpp_430.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int a;
int b;
int c;
int x;
int y;
a = 5;
b = 3;
c = 2;
x = (b + a);
y = (c + b);
if(x < y)
{
ans = (+ 2336);
halt;
}
else
{
if(x > y)
{
ans = (+ 198);
}
else
{
ans = (+ 130);
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>11</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": 0,
"b": 0,
"c": 0,
"d": null,
"f": null,
"x": 0,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
"B": ... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_467.imp | int ans;
int a;
int i;
i = 1;
a = 33;
while(a > 0)
{
ans = (ans + ((a % 8) * i));
a = (a / 8);
i = (i * 10);
}; | mbpp_467.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int a;
int i;
i = 1;
a = 33;
while(a < 0)
{
ans = (ans - ((a % 8) / i));
a = (a * 8);
i = (i / 10);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_47.imp | int xyz;
int ans;
int p;
int q;
int j;
xyz = 1;
p = 6;
q = 8;
if(p == q)
{
ans = 1;
halt;
}
else
{
};
if((q - p) >= 5)
{
ans = 0;
halt;
}
else
{
};
j = (p + 1);
while(j <= q)
{
xyz = ((xyz * (j % 10)) % 10);
j = (j + 1);
};
ans = (xyz % 10); | mbpp_47.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int xyz;
int ans;
int p;
int q;
int j;
xyz = 1;
p = 6;
q = 8;
if(p != q)
{
ans = 1;
halt;
}
else
{
};
if((q + p) <= 5)
{
ans = 0;
halt;
}
else
{
};
j = (p - 1);
while(j >= q)
{
xyz = ((xyz / (j % 10)) % 10);
j = (j - 1);
};
ans = (xyz % 10); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>15</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>5</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": 0,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_479.imp | int ans;
int n;
n = 456;
while(n > 0)
{
ans = (n % 10);
n = (n / 10);
}; | mbpp_479.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
n = 456;
while(n < 0)
{
ans = (n % 10);
n = (n * 10);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_483.imp | int ans;
int x;
int y;
int i;
x = 15;
y = 1;
i = 1;
while(y < x)
{
y = (y * i);
i = (i + 1);
};
ans = i; | mbpp_483.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int x;
int y;
int i;
x = 15;
y = 1;
i = 1;
while(y > x)
{
y = (y / i);
i = (i - 1);
};
ans = i; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": 0,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_5.imp | int n;
int i;
int ans;
n = 9;
i = 2;
while(i < n)
{
if((n % i) == 0)
{
ans = i;
halt;
}
else
{
};
i = (i + 1);
};
ans = (n - 1); | mbpp_5.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int i;
int ans;
n = 9;
i = 2;
while(i > n)
{
if((n % i) != 0)
{
ans = i;
halt;
}
else
{
};
i = (i - 1);
};
ans = (n + 1); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_501.imp | int ans;
int y;
int x;
x = 12;
y = 24;
while(y > 0)
{
if((x % y) == 0)
{
ans = (ans + 1);
}
else
{
};
y = (y - 1);
}; | mbpp_501.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int y;
int x;
x = 12;
y = 24;
while(y < 0)
{
if((x % y) != 0)
{
ans = (ans - 1);
}
else
{
};
y = (y + 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_502.imp | int i;
int j;
int ans;
int n;
int m;
n = 3;
m = 3;
while(i < n)
{
j = 0;
while(j < m)
{
if(i == j)
{
ans = (((n - i) - 1) % 2);
halt;
}
else
{
};
j = (j + 1);
};
i = (i + 1);
};
ans = 1; | mbpp_502.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int i;
int j;
int ans;
int n;
int m;
n = 3;
m = 3;
while(i > n)
{
j = 0;
while(j > m)
{
if(i != j)
{
ans = (((n + i) + 1) % 2);
halt;
}
else
{
};
j = (j - 1);
};
i = (i - 1);
};
ans = 1; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>4</rule>
<rule>8</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": 0,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_506.imp | int ans;
int i;
int k;
int n;
n = 10;
k = 3;
ans = 1;
while(i < k)
{
ans = (ans * (n - i));
i = (i + 1);
}; | mbpp_506.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int k;
int n;
n = 10;
k = 3;
ans = 1;
while(i > k)
{
ans = (ans / (n + i));
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_509.imp | int ans;
int i;
int n;
n = 11;
i = 1;
while(i <= n)
{
ans = (ans + i);
i = (i + 1);
};
ans = (ans / n); | mbpp_509.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int n;
n = 11;
i = 1;
while(i >= n)
{
ans = (ans - i);
i = (i - 1);
};
ans = (ans * n); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_51.imp | int ans;
int x;
int y;
int z;
x = 5;
y = 5;
z = 5;
if((x == y) && (y == z))
{
ans = 1;
halt;
}
else
{
};
ans = 0; | mbpp_51.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int x;
int y;
int z;
x = 5;
y = 5;
z = 5;
if((x != y) || (y != z))
{
ans = 1;
halt;
}
else
{
};
ans = 0; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_511.imp | int ans;
int i;
int n;
i = 2;
n = 105;
while(n > 1)
{
if((n % i) == 0)
{
ans = (ans + i);
n = (n / i);
}
else
{
i = (i + 1);
};
}; | mbpp_511.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int i;
int n;
i = 2;
n = 105;
while(n < 1)
{
if((n % i) != 0)
{
ans = (ans - i);
n = (n * i);
}
else
{
i = (i - 1);
};
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_518.imp | int ans;
int a;
int b;
int num;
int c;
num = 400;
a = 0;
b = num;
while(a <= b)
{
c = (a + ((b - a) / 2));
if((c * c) < num)
{
a = (c + 1);
}
else
{
b = (c - 1);
};
};
ans = a; | mbpp_518.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int a;
int b;
int num;
int c;
num = 400;
a = 0;
b = num;
while(a >= b)
{
c = (a - ((b + a) * 2));
if((c / c) > num)
{
a = (c - 1);
}
else
{
b = (c + 1);
};
};
ans = a; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>6</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="9">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_52.imp | int xyz;
int p;
int ans;
int q;
int r;
xyz = 0;
p = 0;
q = 15;
r = 20;
while(p < r)
{
xyz = (xyz + q);
p = (p + 1);
};
ans = xyz; | mbpp_52.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int xyz;
int p;
int ans;
int q;
int r;
xyz = 0;
p = 0;
q = 15;
r = 20;
while(p > r)
{
xyz = (xyz - q);
p = (p - 1);
};
ans = xyz; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_521.imp | int x;
int y;
int z;
int ans;
x = 6;
y = 15;
z = 20;
if(((z % y) != 0) && ((x % z) != 0))
{
ans = 1;
}
else
{
ans = 0;
}; | mbpp_521.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int x;
int y;
int z;
int ans;
x = 6;
y = 15;
z = 20;
if(((z % y) == 0) || ((x % z) == 0))
{
ans = 1;
}
else
{
ans = 0;
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>17</rule>
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>17</rule>
<rule>19</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_547.imp | int ans;
int n;
n = 5;
while(n > 0)
{
ans = (ans + n);
n = (n / 2);
}; | mbpp_547.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
n = 5;
while(n < 0)
{
ans = (ans - n);
n = (n * 2);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_55.imp | int x;
int b;
int ans;
int c;
int d;
int e;
b = 1;
c = 2;
d = 6;
e = 3;
x = c;
while(b < d)
{
x = (x * e);
if(x < 0)
{
x = (x + 2);
}
else
{
};
b = (b + 1);
};
ans = x; | mbpp_55.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int x;
int b;
int ans;
int c;
int d;
int e;
b = 1;
c = 2;
d = 6;
e = 3;
x = c;
while(b > d)
{
x = (x / e);
if(x > 0)
{
x = (x - 2);
}
else
{
};
b = (b - 1);
};
ans = x; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>12</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": 0,
"c": 0,
"d": null,
"f": null,
"x": 0,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
"B... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_558.imp | int ans;
int n1;
int n2;
n1 = 123;
n2 = 256;
while(n1 > 0)
{
ans = (ans + ((n2 % 10) - (n1 % 10)));
n1 = (n1 / 10);
n2 = (n2 / 10);
}; | mbpp_558.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n1;
int n2;
n1 = 123;
n2 = 256;
while(n1 < 0)
{
ans = (ans - ((n2 % 10) + (n1 % 10)));
n1 = (n1 * 10);
n2 = (n2 * 10);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>1</rule>
<rule>8</rule>
<rule>4</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_566.imp | int ans;
int n;
n = 97;
while(n > 0)
{
ans = (ans + (n % 10));
n = (n / 10);
}; | mbpp_566.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
n = 97;
while(n < 0)
{
ans = (ans - (n % 10));
n = (n * 10);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_575.imp | int ans;
int n;
int a;
int c;
int i;
int l;
int r;
a = 3;
n = 6;
l = 4;
r = 20;
i = l;
while(i <= r)
{
if((i % a) != 0)
{
c = (c + 1);
}
else
{
};
if(c == n)
{
ans = i;
halt;
}
else
{
};
i = (i + 1);
};
ans = (- 1); | mbpp_575.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
int a;
int c;
int i;
int l;
int r;
a = 3;
n = 6;
l = 4;
r = 20;
i = l;
while(i >= r)
{
if((i % a) == 0)
{
c = (c - 1);
}
else
{
};
if(c != n)
{
ans = i;
halt;
}
else
{
};
i = (i - 1);
};
ans = (+ 1); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>17</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>1</rule>
<rule>8</rule>
<rule>17</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="7">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="8">
<rule>1</rule>
<rule>1</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="9">
<rule>26</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": 0,
"b": null,
"c": 0,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,
... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_59.imp | int ans;
int n;
n = 10;
ans = (((3 * n) * n) - (2 * n)); | mbpp_59.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
n = 10;
ans = (((3 / n) / n) + (2 / n)); | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_600.imp | int ans;
int n;
int b;
b = 1;
n = 2;
while(n > 0)
{
if((n % 2) == 0)
{
b = (b * 2);
n = (n / 2);
}
else
{
b = (b * 3);
n = (n / 3);
};
};
if((b % 2) == 0)
{
ans = 1;
}
else
{
}; | mbpp_600.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int ans;
int n;
int b;
b = 1;
n = 2;
while(n < 0)
{
if((n % 2) != 0)
{
b = (b / 2);
n = (n * 2);
}
else
{
b = (b / 3);
n = (n * 3);
};
};
if((b % 2) != 0)
{
ans = 1;
}
else
{
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>6</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>8</rule>
<rule>16</rule>
<rule>23</rule>
<rule>26</rule>
</answer>
<answer id="6">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="7">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": 0,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_626.imp | int r;
int l;
int r2;
int l2;
int ans;
int f;
r = 2;
l = (r - 1);
r2 = (r * 2);
l2 = (l * 2);
f = 0;
while((l2 - l) > 1)
{
if((l % 2) == 0)
{
l = (l / 2);
}
else
{
l = (((l * 3) - r) + 1);
};
if(l2 > l)
{
ans = (- 1);
halt;
}
else
{
};
f = (l * (l + l2));
if(f > r2)
{
ans = f;
halt;
}
else
{
};
};
ans = r2; | mbpp_626.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int r;
int l;
int r2;
int l2;
int ans;
int f;
r = 2;
l = (r + 1);
r2 = (r / 2);
l2 = (l / 2);
f = 0;
while((l2 + l) < 1)
{
if((l % 2) != 0)
{
l = (l * 2);
}
else
{
l = (((l / 3) + r) - 1);
};
if(l2 < l)
{
ans = (+ 1);
halt;
}
else
{
};
f = (l / (l - l2));
if(f < r2)
{
ans = f;
halt;
}
else
{
};
};
ans = r2; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>1</rule>
<rule>4</rule>
<rule>21</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>4</rule>
<rule>14</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>21</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": 0,
"X": null,... | |
srp-mk-K-addSub_mulDiv_negateRelation-mbpp_634.imp | int n;
int i;
int j;
int ans;
i = 1;
n = 3;
while(i <= n)
{
j = (2 * i);
ans = (ans + (((j * j) * j) * j));
i = (i + 1);
}; | mbpp_634.imp | K | module IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
imports INT
imports BOOL
imports LIST
imports MAP
imports ID
imports STRING
imports K-LOCATIONS
syntax AExp ::= Int | Id
| "-" AExp [strict]
| "+" AExp [strict]
> left:
AExp "*" AExp [strict]
| AExp "/" AExp [strict]
| AExp "%" AExp [strict]
> left:
AExp "-" AExp [strict]
| AExp "+" AExp [strict]
> PAExp
syntax PAExp ::= "(" AExp ")" [klabel(parenthesizedA), symbol]
syntax BExp ::= Bool
> "!" BExp [strict]
> left:
AExp ">" AExp [seqstrict]
| AExp ">=" AExp [seqstrict]
| AExp "<" AExp [seqstrict]
| AExp "<=" AExp [seqstrict]
| AExp "!=" AExp [seqstrict]
| AExp "==" AExp [seqstrict]
> left:
BExp "||" BExp [seqstrict]
| BExp "&&" BExp [seqstrict]
> PBExp
syntax PBExp ::= "(" BExp ")" [klabel(parenthesizedB), symbol]
syntax Block ::= "{" "}"
| "{" Stmt "}"
syntax ContMark ::= "continueMarker"
syntax WhileStmt ::= "while" "(" BExp ")" Block ";"
syntax CompStmt ::= Id "=" AExp ";" [strict(2)]
| "if" "(" BExp ")" Block "else" Block ";" [strict(1)]
| WhileStmt
| "while1" "(" BExp ")" Block
| "halt" ";"
| "break" ";"
| "continue" ";"
| "int" Id ";"
syntax Stmt ::= Block
| CompStmt
| ContMark
| "Empty"
> Stmt Stmt [left]
syntax Log ::= "printLine" "(" Int ")" ";"
| "printLine2" "(" Int ")" ";"
| "printStmt" "(" CompStmt ")" ";"
| "printState" ";"
| "emptyRules" ";"
| "printStackTop" ";"
syntax WhileStmt [locations]
syntax CompStmt [locations]
syntax Pgm ::= Stmt
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-SYNTAX
syntax KResult ::= Int | Bool
syntax KItem ::= "breakMarker"
syntax KItem ::= "ERROR"
syntax Bool ::= isContmark(Stmt) [function]
rule isContmark(S:ContMark) => true
rule isContmark(_) => false [owise]
syntax KItem ::= push(Int)
syntax KItem ::= "pop"
syntax KItem ::= pushStmt(Stmt)
syntax KItem ::= "popStmt"
configuration <T>
<k> $PGM:Pgm </k>
<state> $STATE:Map </state>
<lines> .List </lines>
<states> .List </states>
<stmts> .List </stmts>
<rules> .List </rules>
<currentLine> 0 </currentLine>
<whileStack> .List </whileStack>
<whileStmtStack> .List </whileStmtStack>
<whileLine> 0 </whileLine>
</T>
rule <k> push(X:Int) => . ... </k>
<whileStack> S:List => ListItem(X) S </whileStack>
rule <k> pop => . ... </k>
<whileStack> ListItem(X:Int) S:List => S </whileStack>
rule <k> pushStmt(S:Stmt) => . ... </k>
<whileStmtStack> L:List => ListItem(S) L </whileStmtStack>
rule <k> popStmt => . ... </k>
<whileStmtStack> ListItem(S:Stmt) L:List => L </whileStmtStack>
rule #location(S:CompStmt, File, StartLine, _, _, _) => printLine(StartLine); ~> printStmt(S); ~> printState; ~> printStackTop; ~> S
rule #location(S:WhileStmt, File, StartLine, _, _, _) => printLine2(StartLine); ~> S
rule {} => .
rule {S} => S
rule S1:Stmt S2:Stmt => S1 ~> S2
rule <k> parenthesizedA(P:AExp) => P ... </k>
rule <k> parenthesizedB(P:BExp) => P ... </k>
rule <k> ERROR ~> _ => .</k>
rule <k> printStmt(A:CompStmt) ; => . ...</k>
<stmts> OUT => OUT ListItem(A)</stmts>
rule <k> printLine(A:Int) ; => . ...</k>
<lines> OUT => OUT ListItem(A)</lines>
<currentLine> _ => A </currentLine>
rule <k> printLine2(A:Int) ; => . ...</k>
<currentLine> _ => A </currentLine>
rule <k> printState; => . ...</k>
<state> ST </state>
<states> OUT => OUT ListItem(ST)</states>
<rules> L => L ListItem("BREAK") </rules>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> ListItem(S:Stmt) L:List</whileStmtStack>
rule <k> printStackTop; => . ...</k>
<whileStmtStack> .List</whileStmtStack>
endmodule
module IMP_K_ADDSUB_MULDIV_NEGATERELATION
imports IMP_K_ADDSUB_MULDIV_NEGATERELATION-AUXILIARY
rule [1]:
<k> X:Id => I ...</k>
<state>... X |-> I ...</state>
<rules> L => L ListItem("Rule 1") </rules>
rule [2]:
<k> X:Id => ERROR </k>
<state> Rho:Map </state>
<rules> L => L ListItem("Rule 2") </rules>
requires notBool (X in_keys(Rho))
rule [3]:
<k> I1 - I2 => I1 +Int I2 ... </k>
<rules> L => L ListItem("Rule 3") </rules>
rule [4]:
<k> I1 + I2 => I1 -Int I2 ... </k>
<rules> L => L ListItem("Rule 4") </rules>
rule [5]:
<k> I1 / I2 => I1 *Int I2 ... </k>
<rules> L => L ListItem("Rule 5") </rules>
rule [6]:
<k> I1 * I2 => I1 /Int I2 ... </k>
<rules> L => L ListItem("Rule 6") </rules>
requires I2 =/=Int 0
rule [7]:
<k> I1 * I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 7") </rules>
requires I2 ==Int 0
rule [8]:
<k> I1 % I2 => I1 %Int I2 ... </k>
<rules> L => L ListItem("Rule 8") </rules>
requires I2 =/=Int 0
rule [9]:
<k> I1 % I2 => ERROR ... </k>
<rules> L => L ListItem("Rule 9") </rules>
requires I2 ==Int 0
rule [10]:
<k> - I1 => 0 +Int I1 ... </k>
<rules> L => L ListItem("Rule 10") </rules>
rule [11]:
<k> + I1 => 0 -Int I1 ... </k>
<rules> L => L ListItem("Rule 11") </rules>
rule [12]:
<k> I1 > I2 => I1 <Int I2 ... </k>
<rules> L => L ListItem("Rule 12") </rules>
rule [13]:
<k> I1 >= I2 => I1 <=Int I2 ... </k>
<rules> L => L ListItem("Rule 13") </rules>
rule [14]:
<k> I1 < I2 => I1 >Int I2 ... </k>
<rules> L => L ListItem("Rule 14") </rules>
rule [15]:
<k> I1 <= I2 => I1 >=Int I2 ... </k>
<rules> L => L ListItem("Rule 15") </rules>
rule [16]:
<k> I1 != I2 => I1 ==Int I2 ... </k>
<rules> L => L ListItem("Rule 16") </rules>
rule [17]:
<k> I1 == I2 => I1 =/=Int I2 ... </k>
<rules> L => L ListItem("Rule 17") </rules>
rule [18]:
<k> ! B1 => notBool B1 ... </k>
<rules> L => L ListItem("Rule 18") </rules>
rule [19]:
<k> B1 || B2 => B1 andBool B2 ... </k>
<rules> L => L ListItem("Rule 19") </rules>
rule [20]:
<k> B1 && B2 => B1 orBool B2 ... </k>
<rules> L => L ListItem("Rule 20") </rules>
rule [21]:
<k> X = I:Int; => . ...</k>
<state>... X |-> (_ => I) ...</state>
<rules> L => L ListItem("Rule 21") </rules>
rule [22]:
<k> if (true) S else _ ; => S ... </k>
<rules> L => L ListItem("Rule 22") </rules>
rule [23]:
<k> if (false) _ else S ; => S ... </k>
<rules> L => L ListItem("Rule 23") </rules>
rule [24]:
<k> (while (B) S ;) => push(R) ~> pushStmt((while (B) S ;)) ~> (while1 (B) S) ~> breakMarker ~> pop ~> popStmt ... </k>
<currentLine> R:Int </currentLine>
<rules> L => L ListItem("Rule 24") </rules>
rule [25]:
<k> while1 (B) S => printLine(X); ~> printStmt((while (B) S ;)); ~> printState; ~> printStackTop; ~> if (B) {S continueMarker (while1 (B) S)} else {}; ...</k>
<whileStack> ListItem(X:Int) S1:List</whileStack>
<whileLine> _ => X </whileLine>
<rules> L => L ListItem("Rule 25") </rules>
rule [26]:
<k> halt; ~> _ => .</k>
<rules> L => L ListItem("Rule 26") </rules>
rule [27]:
<k> breakMarker => . ... </k>
<rules> L => L ListItem("Rule 27") </rules>
rule [28]:
<k> S:ContMark => . ... </k>
<rules> L => L ListItem("Rule 28") </rules>
rule [29]:
<k> continue; ~> S:ContMark => . ...</k>
<rules> L => L ListItem("Rule 29") </rules>
rule [30]:
<k> continue; ~> S:Stmt => continue; ...</k>
<rules> L => L ListItem("Rule 30") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
requires notBool isContmark(S)
rule [31]:
<k> continue; => ERROR </k>
<rules> L => L ListItem("Rule 31") </rules>
<whileStack> .List </whileStack>
rule [32]:
<k> continue; ~> breakMarker => continue; ...</k>
<rules> L => L ListItem("Rule 32") </rules>
rule [33]:
<k> break; ~> S:Stmt => break; ...</k>
<rules> L => L ListItem("Rule 33") </rules>
<whileStack> ListItem(_) REST:List </whileStack>
rule [34]:
<k> break; => ERROR </k>
<rules> L => L ListItem("Rule 34") </rules>
<whileStack> .List </whileStack>
rule [35]:
<k> break; ~> breakMarker => . ...</k>
<rules> L => L ListItem("Rule 35") </rules>
rule [36]:
<k> int X; => . ... </k>
<state> Rho:Map (.Map => X|->0) </state>
<rules> L => L ListItem("Rule 36") </rules>
endmodule
| IMP | int n;
int i;
int j;
int ans;
i = 1;
n = 3;
while(i >= n)
{
j = (2 / i);
ans = (ans - (((j / j) / j) / j));
i = (i - 1);
}; | true | KeywordSwap | true | <ans>
<answer id="0">
<rule>36</rule>
</answer>
<answer id="1">
<rule>21</rule>
</answer>
<answer id="2">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>22</rule>
<rule>26</rule>
</answer>
<answer id="3">
<rule>1</rule>
<rule>5</rule>
<rule>21</rule>
</answer>
<answer id="4">
<rule>1</rule>
<rule>1</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>1</rule>
<rule>5</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="5">
<rule>1</rule>
<rule>3</rule>
<rule>21</rule>
</answer>
<answer id="6">
<rule>24</rule>
<rule>25</rule>
<rule>1</rule>
<rule>1</rule>
<rule>13</rule>
<rule>23</rule>
<rule>27</rule>
</answer>
</ans> | [
{
"line_number": 1,
"prior_state": {
"ble": 0,
"ans": null,
"num": null,
"a": null,
"b": null,
"c": null,
"d": null,
"f": null,
"x": null,
"j": null,
"k": null,
"m": null,
"p": null,
"q": null,
"r": null,
"X": nu... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.