Manipulate[
Quiet[
Module[{systemSolution,noSolutionFlag,pointSolutionFlag,lineSolutionFlag,planeSolutionFlag,solX,solY,solZ,𝒫1SolutionExist,𝒫2SolutionExist,𝒫3SolutionExist,𝒫1Solution,𝒫2Solution,𝒫3Solution,xRange=30,yRange=30,zRange=30,arrowHead,arrow,plotPlane,plotLineSolution,showNothing,planeEqTo3D},

planeEqTo3D[planeEq_,color_]:=plotPlane[(Union[StringCases[ToString[{x,y,z}/.planeEq],ch:CharacterRange["x","z"]]]/.{"x"->x,"y"->y,"z"->z}),{x,y,z}/.planeEq[[1]],color];

arrowHead[headBegin_,headEnd_,sections_,beginRadius_,endRadius_,color_]:=Module[{interval,radiusInterval},interval=(headEnd-headBegin)/sections;
radiusInterval=(beginRadius-endRadius)/(sections-1);
Map[{color,Cylinder[#[[1]],#[[2]]]}&,Transpose[{Partition[NestList[#+interval&,headBegin,sections],2,1],NestList[(#-radiusInterval)&, beginRadius,(sections-1)]}]]
];

arrow[arrowBegin_,arrowEnd_,lineThickness_,setColor_]:={{Thickness[lineThickness],setColor,Line[{arrowBegin,(arrowEnd-(((arrowEnd-arrowBegin)/6)))}]},{EdgeForm[],
arrowHead[(arrowEnd-(((arrowEnd-arrowBegin)/6))),arrowEnd,10,(range/30),0.02,setColor]}};

plotPlane[{lx_,ly_},pEq_,color_]:=ParametricPlot3D[pEq,{lx,-range,range},{ly,-range,range},PlotStyle->color];

plotPlane[{lx_},pEq_,color_]:=ParametricPlot3D[pEq,{lx,-range,range},PlotStyle->color];

plotLineSolution[{lx_},sx_,sy_,sz_]:=ParametricPlot3D[{sx,sy,sz},{lx,-range,range},PlotStyle->{Thickness[(range/3750)],Red}];

plotLineSolution[{lx_,ly_},sx_,sy_,sz_]:=ParametricPlot3D[{sx,sy,sz},{lx,-range,range},{ly,-range,range},PlotStyle->{Thickness[(range/3750)],Red}];

(* adjustSliderMinMax enables adjustments of the slider-parameter's minimum and maximum when performing row operations, and thereby prevents the sliders from turning pink. *)
adjustSliderMinMax[param_,paramMin_,paramMax_]:=
With[{tempParamMin=Unevaluated[paramMin],tempParamMax=Unevaluated[paramMax]},
{
If[param<paramMin,tempParamMin=param,If[param>paramMax,tempParamMax=param,If[param≥-20,{tempParamMin=-20;If[param≤20,tempParamMax=20,Null]},Null]
]
]
}];(* end With *)

showNothing=Plot3D[Null,{x,0,1},{y,0,1}];

(* the next two If statements enables the user to see the system in its reduced row echolon form when showRowReduced is True and 
after return to the system's parameters prior to being shown in a reduced row echelon form. The variables a1m... act as memory. *)
If[(!showRowReduced && !firstTimeNotRowReduced),
{firstTimeNotRowReduced=True;
a1=a1mr;b1=b1mr;c1=c1mr;d1=d1mr;
a2=a2mr;b2=b2mr;c2=c2mr;d2=d2mr;
a3=a3mr;b3=b3mr;c3=c3mr;d3=d3mr},
Null];

If[(showRowReduced&&firstTimeNotRowReduced),
{firstTimeNotRowReduced=False;
a1mr=a1;b1mr=b1;c1mr=c1;d1mr=d1;
a2mr=a2;b2mr=b2;c2mr=c2;d2mr=d2;
a3mr=a3;b3mr=b3;c3mr=c3;d3mr=d3;
{{a1,b1,c1,d1},{a2,b2,c2,d2},{a3,b3,c3,d3}}=RowReduce[{{a1,b1,c1,d1},{a2,b2,c2,d2},{a3,b3,c3,d3}}]},
Null];

(* the next two If statements enables the user to return to the parameters that he or she was working with
prior to looking at the examples. *)
If[(!example==1&&firstTimeNotOneFlag),
{firstTimeNotOneFlag=False;
a1m=a1;b1m=b1;c1m=c1;d1m=d1;
a2m=a2;b2m=b2;c2m=c2;d2m=d2;
a3m=a3;b3m=b3;c3m=c3;d3m=d3},
Null;];

If[(example==1&&!firstTimeNotOneFlag),
{firstTimeNotOneFlag=True;
a1=a1m;b1=b1m;c1=c1m;d1=d1m;
a2=a2m;b2=b2m;c2=c2m;d2=d2m;
a3=a3m;b3=b3m;c3=c3m;d3=d3m},
Null;];

Switch[example,
2,
(* insert the new parameters for a point solution made from perpendicular planes *)
{firstTimeNotOneFlag=False;
a1=0;b1=0 ;c1=-5 ;d1=0;
a2=0;b2=-7; c2=0;d2=0;
a3=9;b3=0;c3=0; d3=0},

3,
(* line solution *)
{firstTimeNotOneFlag=False;
a1=0;b1=0 ;c1=-3 ;d1=0;
a2=7;b2=0; c2=-4;d2=0;
a3=7;b3=0;c3=0; d3=0},

4,
(* plane solution *)
{firstTimeNotOneFlag=False;
a1=-4;b1=-2 ;c1=-3 ;d1=13;
a2=-4;b2=-2; c2=-3;d2=13;
a3=-4;b3=-2;c3=-3; d3=13},

5,
(* no solution  *)
{firstTimeNotOneFlag=False;
a1=0;b1=0 ;c1=-3 ;d1=13;
a2=7;b2=0; c2=-4;d2=0;
a3=7;b3=0;c3=0; d3=20}
];

xRange=range;yRange=range;zRange=range;

𝒫1=a1 x+b1 y+c1 z==d1;
𝒫2=a2 x+b2 y+c2 z==d2;
𝒫3=a3 x+b3 y+c3 z==d3;

(* The complete system of equations *)
eqs={𝒫1,𝒫2,𝒫3};

systemSolution=Solve[eqs,{x,y,z}][[1]];
(* If length of systemSolution == 3 then there is a single point solution *)
If[Length[systemSolution]==3&&StringFreeQ[ToString[systemSolution],"{}"],{{solX,solY,solZ}={x,y,z}/.systemSolution;pointSolutionFlag=True},pointSolutionFlag=False];
(* If length of systemSolution == 2 then a line is the solution to the system *)
If[Length[systemSolution]==2&&StringFreeQ[ToString[systemSolution],"{}"],{{solX,solY,solZ}={x,y,z}/.systemSolution;lineSolutionFlag=True},lineSolutionFlag=False];
(* If length of systemSolution == 1 then plane is the solution to the system *)
If[Length[systemSolution]==1&&StringFreeQ[ToString[systemSolution],"{}"],{{solX,solY,solZ}={x,y,z}/.systemSolution;planeSolutionFlag=True},planeSolutionFlag=False];
(* If length of systemSolution == 0 then there is no solution to the system *)
If[StringFreeQ[ToString[systemSolution],"{}"],noSolutionFlag=False,noSolutionFlag=True];

(* Check which rows have solutions and can be drawn as planes and with normal vectors *)
𝒫1Solution=Solve[𝒫1,{x,y,z}]; 𝒫1SolutionExist=StringFreeQ[ToString[𝒫1Solution],"{}"];
𝒫2Solution=Solve[𝒫2,{x,y,z}]; 𝒫2SolutionExist=StringFreeQ[ToString[𝒫2Solution],"{}"];
𝒫3Solution=Solve[𝒫3,{x,y,z}]; 𝒫3SolutionExist=StringFreeQ[ToString[𝒫3Solution],"{}"];

(* Display text etc. below the graphics window by using Labeled *)
Labeled[Show[
Graphics3D[{
If[showNormalVectors,
{If[𝒫1SolutionExist,arrow[{0,0,0},(Normalize[{a1,b1,c1}]*(range-5)),0.005,colorP1],Point[{0,0,0}]],
If[𝒫2SolutionExist,arrow[{0,0,0},(Normalize[{a2,b2,c2}]*(range-5)),0.005,colorP2],Point[{0,0,0}]],
If[𝒫3SolutionExist,arrow[{0,0,0},(Normalize[{a3,b3,c3}]*(range-5)),0.005,colorP3],Point[{0,0,0}]]
},Point[{0,0,0}] 
],

(* if a point solution exists show it as a red sphere *)
If[pointSolutionFlag,{Red,Sphere[{solX,solY,solZ},(range/30)]},Point[{0,0,0}]],Point[{0,0,0}],

(* Insert the x,y,z axes  *)
Line[{{0,0,-range},{0,0,range}}],Text[z,{0,0,range+1}],Line[{{-range,0,0},{range,0,0}}],Text[x,{range+1,0,0}],Line[{{0,-range,0},{0,range,0}}],Text[y,{0,range+1,0}]}
], (* end Graphics3D *)

If[lineSolutionFlag,
 (* Find out which variables are given to plot the line solution, it can be a combination of x,y or z *)
plotLineSolution[Union[StringCases[ToString[{solX,solY,solZ}],ch:CharacterRange["x","z"]]]/.{"x"->x,"y"->y,"z"->z},solX,solY,solZ],
showNothing ],

If[𝒫1SolutionExist,planeEqTo3D[𝒫1Solution,colorP1],showNothing],
If[𝒫2SolutionExist,planeEqTo3D[𝒫2Solution,colorP2],showNothing],
If[𝒫3SolutionExist,planeEqTo3D[𝒫3Solution,colorP3],showNothing],

If[planeSolutionFlag,
(* since all planes lie in the same plane show one of the planes in red as the solution *)
planeEqTo3D[Solve[𝒫1,{x,y,z}],Red],
showNothing],

FaceGrids->{{-1,0,0},{0,-1,0},{0,0,-1}},
Axes->True,
AxesLabel->{x,y,z},
PlotRange->{{-xRange,xRange},{-yRange,yRange},{-zRange,zRange}},
Background->RGBColor[0.922,0.918,0.941],
ImageSize->{400,350},
Lighting->"Neutral",
ViewPoint->{4.6,6.45,3.55},ImagePadding->25
], (* end Show *)

(* the following lines correspond with the Labeled keyword above and thereby inserts the text below the graphics window *)
Pane[
Row[{
Pane[
If[showAugmentedMatrix,
Column[{
(* show linear system as augmented matrix *)
(* RowBox is used here rather than Row to make the enclosing parentheses span all three rows of the augmented matrix *)
RowBox[{"(",Grid[{Style[#,12,colorP1]&/@{TraditionalForm[a1],TraditionalForm[b1],ToString[TraditionalForm[c1]]<>" "," "<>ToString[TraditionalForm[d1]]},Style[#,12,colorP2]&/@{TraditionalForm[a2],TraditionalForm[b2],ToString[TraditionalForm[c2]]<>" "," "<>ToString[TraditionalForm[d2]]},Style[#,12,colorP3]&/@{TraditionalForm[a3],TraditionalForm[b3],ToString[TraditionalForm[c3]]<>" "," "<>ToString[TraditionalForm[d3]]}},Dividers->{{False,False,False,True},{}},FrameStyle->Thickness[1],Alignment->Center,Spacings->{1,1}
],")"}]//DisplayForm (* end RowBox *)
}],(* end Column *)
Column[{
Text@Style["     "~~ToString[TraditionalForm[a1 x+b1 y+c1 z]]~~" = "~~ToString[TraditionalForm[d1]]~~"",12,colorP1],
Text@TraditionalForm[Text@Style["     "~~ToString[TraditionalForm[a2 x+b2 y+c2 z]]~~" = "~~ToString[TraditionalForm[d2]]~~"",12,colorP2]],
Text@TraditionalForm[Style["     "~~ToString[TraditionalForm[a3 x+b3 y+c3 z]]~~" = "~~ToString[TraditionalForm[d3]]~~"",12,colorP3]]
}] (* end Column *)
], (* end If *)
ImageSize->{200,90}
],(* end Pane *)
Pane[
If[noSolutionFlag,
Text@Style["No solution (inconsistent)",12],
Text@Style[TraditionalForm["   Solution: \n"~~StringReplace[ToString[TraditionalForm[systemSolution]],"->"..->"="]],12]
], (* end If *)
ImageSize->{160,90}
] (* end Pane *)
}], (* end Row *)
ImageSize->{400,90}
] (* end Pane *) 
 ] (* end Labeled *)
] (* end Quiet *)
],(* end Module *)

(* user-interface *)

Row[{
TabView[{
Style[Tooltip["row 1","set parameters for row 1"],Background->colorP1]->
Column[{
Row[{"a11"," ",InputField[Dynamic[a1],Number]," ",Dynamic[a1]}],
Row[{"a12"," ",InputField[Dynamic[b1],Number]," ",Dynamic[b1]}],
Row[{"a13"," ",InputField[Dynamic[c1], Number]," ",Dynamic[c1]}],
Row[{" b1"," ",InputField[Dynamic[d1],Number]," ",Dynamic[d1]}]
}],(* end Column *)
Style[Tooltip["row 2","set parameters for row 2"],Background->colorP2]->
Column[{
Row[{"a11"," ",InputField[Dynamic[a2],Number]," ",Dynamic[a2]}],
Row[{"a12"," ",InputField[Dynamic[b2],Number]," ",Dynamic[b2]}],
Row[{"a13"," ",InputField[Dynamic[c2],Number]," ",Dynamic[c2]}],
Row[{" b2"," ",InputField[Dynamic[d2],Number]," ",Dynamic[d2]}]
}],(* end Column *)
Style[Tooltip["row 3","set parameters for row 3"],Background->colorP3]->
Column[{
Row[{"a31"," ",InputField[Dynamic[a3],Number]," ",Dynamic[a3]}],
Row[{"a32"," ",InputField[Dynamic[b3],Number]," ",Dynamic[b3]}],
Row[{"a33"," ",InputField[Dynamic[c3],Number]," ",Dynamic[c3]}],
Row[{" b3"," ",InputField[Dynamic[d3],Number]," ",Dynamic[d3]}]
}](* end Column *)
}] (* end TabView *)
}], (* end Row *)

{{example,1,Style[Tooltip["examples","show different types of systems. Note: Disables row reduce checkbox"]]},1,5,1,ImageSize->Tiny,Enabled->(!showRowReduced)},

Row[{
Column[{
Row[{Tooltip["augmented matrix  ","tick to show augmented matrix"],Checkbox[Dynamic[showAugmentedMatrix]]}],
Row[{Tooltip["normal vectors  ","tick to show normal vectors"],Checkbox[Dynamic[showNormalVectors]]}],
Row[{Tooltip["row reduce  ","tick to show reduced row echelon form. Note: disables examples slider"],Checkbox[Dynamic[showRowReduced],Enabled->(example==1)]}]
}] (* end Column *)
}],(* end Row *)

{{range,30,Style[Tooltip["range","adjust range of enclosing box"]]},5,100,1,ImageSize->Tiny},
Delimiter,
Style[Tooltip["elementary row operations","perform the row operations from Gaussian elimination"],Bold],

Row[{
TabView[{
"multiply\nrow"->
Row[{
Column[{
Button["click to multiply",
{If[tickEqNum==1,
{
{a1,b1,c1,d1}=timesNum*{a1,b1,c1,d1};
adjustSliderMinMax[a1,Unevaluated[a1Min],Unevaluated[a1Max]];
adjustSliderMinMax[b1,Unevaluated[b1Min],Unevaluated[b1Max]];
adjustSliderMinMax[c1,Unevaluated[c1Min],Unevaluated[c1Max]];
adjustSliderMinMax[d1,Unevaluated[d1Min],Unevaluated[d1Max]];
},
Null]; (* end If *)
If[tickEqNum==2,
{
{a2,b2,c2,d2}=timesNum*{a2,b2,c2,d2};
adjustSliderMinMax[a2,Unevaluated[a2Min],Unevaluated[a2Max]];
adjustSliderMinMax[b2,Unevaluated[b2Min],Unevaluated[b2Max]];
adjustSliderMinMax[c2,Unevaluated[c2Min],Unevaluated[c2Max]];
adjustSliderMinMax[d2,Unevaluated[d2Min],Unevaluated[d2Max]];
},
Null]; (* end If *)
If[tickEqNum==3,
{
{a3,b3,c3,d3}=timesNum*{a3,b3,c3,d3};
adjustSliderMinMax[a3,Unevaluated[a3Min],Unevaluated[a3Max]];
adjustSliderMinMax[b3,Unevaluated[b3Min],Unevaluated[b3Max]];
adjustSliderMinMax[c3,Unevaluated[c3Min],Unevaluated[c3Max]];
adjustSliderMinMax[d3,Unevaluated[d3Min],Unevaluated[d3Max]];
},
Null]} (* end If *)
],(* end Button *)
Row[{"factor ",PopupMenu[Dynamic[timesNum],{2,3,4,5,6,7,8,9,10,1/10,1/9,1/8,1/7,1/6,1/5,1/4,1/3,1/2,-2,-3,-4,-5,-6,-7,-8,-9,-10,-1/10,-1/9,-1/8,-1/7,-1/6,-1/5,-1/4,-1/3,-1/2},FieldSize->{2.6,2}]
}],
Row[{"row ",RadioButtonBar[Dynamic[tickEqNum],Range[3]]}]
}] (* end Column *)
}] ,(* end Row *)

"swap"->
Row[{
Column[{
Button[Style["click to swap rows",Medium],
{tempList={Hold[{a1,b1,c1,d1}],Hold[{a2,b2,c2,d2}],Hold[{a3,b3,c3,d3}]};
{tempList[[swapEqNum1]],tempList[[swapEqNum2]]}={tempList[[swapEqNum2]],tempList[[swapEqNum1]]};newTempList=ReleaseHold[tempList];
{a1,b1,c1,d1}=newTempList[[1]] ;{a2,b2,c2,d2}=newTempList[[2]];{a3,b3,c3,d3}=newTempList[[3]];
If[(swapEqNum1==1||swapEqNum2==1),
{
adjustSliderMinMax[a1,Unevaluated[a1Min],Unevaluated[a1Max]];
adjustSliderMinMax[b1,Unevaluated[b1Min],Unevaluated[b1Max]];
adjustSliderMinMax[c1,Unevaluated[c1Min],Unevaluated[c1Max]];
adjustSliderMinMax[d1,Unevaluated[d1Min],Unevaluated[d1Max]];
},
Null]; (* end If *)
If[(swapEqNum1==2||swapEqNum2==2),
{
adjustSliderMinMax[a2,Unevaluated[a2Min],Unevaluated[a2Max]];
adjustSliderMinMax[b2,Unevaluated[b2Min],Unevaluated[b2Max]];
adjustSliderMinMax[c2,Unevaluated[c2Min],Unevaluated[c2Max]];
adjustSliderMinMax[d2,Unevaluated[d2Min],Unevaluated[d2Max]];
},
Null]; (* end If *)
If[(swapEqNum1==3||swapEqNum2==3),
{
adjustSliderMinMax[a3,Unevaluated[a3Min],Unevaluated[a3Max]];
adjustSliderMinMax[b3,Unevaluated[b3Min],Unevaluated[b3Max]];
adjustSliderMinMax[c3,Unevaluated[c3Min],Unevaluated[c3Max]];
adjustSliderMinMax[d3,Unevaluated[d3Min],Unevaluated[d3Max]];
},
Null]; (* end If *)
},ImageSize->Medium
],(* end Button "click to swap rows" *) 
Row[{"swap row ",RadioButtonBar[Dynamic[swapEqNum1],Range[3]]}],
Row[{"with row  ",RadioButtonBar[Dynamic[swapEqNum2],Range[3]]}]
}] (* end Column *)
}],(* end Row *)

"add multiple\nof row"->
Row[{
Column[{
Button[Style["click to add multiple of row",Medium],{tempParamList={{a1,b1,c1,d1},{a2,b2,c2,d2},{a3,b3,c3,d3}}; 
tempParamList[[onRowNum]]=Plus[tempParamList[[onRowNum]],(tempParamList[[fromRowNum]]*pmTimes)];
{{a1,b1,c1,d1},{a2,b2,c2,d2},{a3,b3,c3,d3}}=tempParamList;
Which[
onRowNum==1,
{
adjustSliderMinMax[a1,Unevaluated[a1Min],Unevaluated[a1Max]];
adjustSliderMinMax[b1,Unevaluated[b1Min],Unevaluated[b1Max]];
adjustSliderMinMax[c1,Unevaluated[c1Min],Unevaluated[c1Max]];
adjustSliderMinMax[d1,Unevaluated[d1Min],Unevaluated[d1Max]];
},
onRowNum==2,
{
adjustSliderMinMax[a2,Unevaluated[a2Min],Unevaluated[a2Max]];
adjustSliderMinMax[b2,Unevaluated[b2Min],Unevaluated[b2Max]];
adjustSliderMinMax[c2,Unevaluated[c2Min],Unevaluated[c2Max]];
adjustSliderMinMax[d2,Unevaluated[d2Min],Unevaluated[d2Max]];
},
onRowNum==3,
{
adjustSliderMinMax[a3,Unevaluated[a3Min],Unevaluated[a3Max]];
adjustSliderMinMax[b3,Unevaluated[b3Min],Unevaluated[b3Max]];
adjustSliderMinMax[c3,Unevaluated[c3Min],Unevaluated[c3Max]];
adjustSliderMinMax[d3,Unevaluated[d3Min],Unevaluated[d3Max]];
}
]
},ImageSize->Medium],(* end Button "click to add multiple of row" *)
Row[{"of row ",RadioButtonBar[Dynamic[fromRowNum],Range[3]]}],
Row[{"to row ",RadioButtonBar[Dynamic[onRowNum],Range[3]]}],
Row[{"factor ",PopupMenu[Dynamic[pmTimes],{1,2,3,4,5,6,7,8,9,10,1/10,1/9,1/8,1/7,1/6,1/5,1/4,1/3,1/2,-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-1/10,-1/9,-1/8,-1/7,-1/6,-1/5,-1/4,-1/3,-1/2},FieldSize->{2.6,2}]
}]
}](* end Column *)
}] (* end Row *)
}] (* end TabView *)
}], (* end Row *)

(* localize and initialize *)
{{a1,4},ControlType->None},{{b1,2},ControlType->None},{{c1,3},ControlType->None},{{d1,3},ControlType->None},
{{a2,1},ControlType->None},{{b2,2},ControlType->None},{{c2,3},ControlType->None},{{d2,3},ControlType->None},
{{a3,-1},ControlType->None},{{b3,-2},ControlType->None},{{c3,-1},ControlType->None},{{d3,3},ControlType->None},

{{a1Min,-20},ControlType->None},{{a1Max,20},ControlType->None},
{{b1Min,-20},ControlType->None},{{b1Max,20},ControlType->None},
{{c1Min,-20},ControlType->None},{{c1Max,20},ControlType->None},
{{d1Min,-20},ControlType->None},{{d1Max,20},ControlType->None},
{{a2Min,-20},ControlType->None},{{a2Max,20},ControlType->None},
{{b2Min,-20},ControlType->None},{{b2Max,20},ControlType->None},
{{c2Min,-20},ControlType->None},{{c2Max,20},ControlType->None},
{{d2Min,-20},ControlType->None},{{d2Max,20},ControlType->None},
{{a3Min,-20},ControlType->None},{{a3Max,20},ControlType->None},
{{b3Min,-20},ControlType->None},{{b3Max,20},ControlType->None},
{{c3Min,-20},ControlType->None},{{c3Max,20},ControlType->None},
{{d3Min,-20},ControlType->None},{{d3Max,20},ControlType->None},

{{a1m,4},ControlType->None},{{b1m,2},ControlType->None},{{c1m,3},ControlType->None},{{d1m,3},ControlType->None},
{{a2m,1},ControlType->None},{{b2m,2},ControlType->None},{{c2m,3},ControlType->None},{{d2m,3},ControlType->None},
{{a3m,-1},ControlType->None},{{b3m,-2},ControlType->None},{{c3m,-1},ControlType->None},{{d3m,3},ControlType->None},

{{a1mr,4},ControlType->None},{{b1mr,2},ControlType->None},{{c1mr,3},ControlType->None},{{d1mr,3},ControlType->None},
{{a2mr,1},ControlType->None},{{b2mr,2},ControlType->None},{{c2mr,3},ControlType->None},{{d2mr,3},ControlType->None},
{{a3mr,-1},ControlType->None},{{b3mr,-2},ControlType->None},{{c3mr,-1},ControlType->None},{{d3mr,3},ControlType->None},

{{𝒫1,{}},ControlType->None},{{𝒫2,{}},ControlType->None},{{𝒫3,{}},ControlType->None},{{eqs,{}},ControlType->None},

{{colorP1,RGBColor[0.388,0.6705,0.3607]},ControlType->None},
{{colorP2,RGBColor[0.329,0.259,0.78]},ControlType->None},
{{colorP3,RGBColor[0.788,0.573,0.247]},ControlType->None},
{{showAugmentedMatrix,False},ControlType->None},
{{showNormalVectors,False},ControlType->None},
{{showRowReduced,False},ControlType->None},
{{firstTimeNotOneFlag,True},ControlType->None},
{{firstTimeNotRowReduced,True},ControlType->None},
{{tickEqNum,1},ControlType->None},
{{timesNum,2},ControlType->None},
{{fromRowNum,1},ControlType->None},
{{onRowNum,2},ControlType->None},
{{pmTimes,1},ControlType->None},
{{swapEqNum1,1},ControlType->None},
{{swapEqNum2,2},ControlType->None},
{{tempList,{}},ControlType->None},
{{tempParamList,{}},ControlType->None},
{{newTempList,{}},ControlType->None},

ControlPlacement->Left,TrackedSymbols->Manipulate,AutorunSequencing->{{1,12}}
]