public FeedbackElem()
 {
     id = "";
         message = new FeedbackMessage();
         nextSteps = new Fraction();
         type = 0;
         counter = 0;
 }
        public FeedbackData(String taskID, StudentModel student)
        {
            Debug.Log (":::: FeedbackData taskID: "+taskID);

            int startNumerator = 0;
            int endNumerator = 0;
            int startDenominator = 0;
            int endDenominator = 0;
            int finalNumerator = 0;
            int finalDenominator = 0;
            int resultNumerator = 0;
            int resultDenominator = 0;
            String representation = "area";

            if (taskID.Equals ("task1.1setA")) {
                endDenominator = 5;
            }

            if (taskID.Equals("task2.7.setA")){
                startNumerator = 1;
                endNumerator = 3;
                startDenominator = 6;
                endDenominator = 18;
            }
            else if (taskID.Equals("task2.7.setB")){
                startNumerator = 3;
                endNumerator = 9;
                startDenominator = 4;
                endDenominator = 12;
            }
            else if (taskID.Equals("task2.7.setC")){
                startNumerator = 7;
                endNumerator = 28;
                startDenominator = 3;
                endDenominator = 12;
            }
            else if (taskID.Equals("task2.6.setA")){
                startNumerator = 3;
                startDenominator = 4;
                endNumerator = 1;
                endDenominator = 12;
            }
            else if (taskID.Equals("task2.6.setB")){
                startNumerator = 2;
                startDenominator = 5;
                endNumerator = 1;
                endDenominator = 10;
            }
            else if (taskID.Equals("task2.6.setC")){
                startNumerator = 7;
                startDenominator = 3;
                endNumerator = 1;
                endDenominator = 21;
            }
            else if (taskID.Equals("task2.4.setA.area")){
                startNumerator = 1;
                startDenominator = 2;
            }
            else if (taskID.Equals("task2.4.setB.area")){
                startNumerator = 3;
                startDenominator = 4;
            }
            else if (taskID.Equals("task2.4.setC.area")){
                startNumerator = 7;
                startDenominator = 3;
            }
            else if (taskID.Equals("task2.4.setA.numb")){
                startNumerator = 1;
                startDenominator = 2;
                representation = "number line";
            }
            else if (taskID.Equals("task2.4.setB.numb")){
                startNumerator = 3;
                startDenominator = 4;
                representation = "number line";
            }
            else if (taskID.Equals("task2.4.setC.numb")){
                startNumerator = 7;
                startDenominator = 3;
                representation = "number line";
            }
            else if (taskID.Equals("task2.4.setA.sets")){
                startNumerator = 1;
                startDenominator = 2;
                representation = "sets";
            }
            else if (taskID.Equals("task2.4.setB.sets")){
                startNumerator = 3;
                startDenominator = 4;
                representation = "sets";
            }
            else if (taskID.Equals("task2.4.setC.sets")){
                startNumerator = 7;
                startDenominator = 3;
                representation = "sets";
            }
            else if (taskID.Equals("task2.4.setA.liqu")){
                startNumerator = 1;
                startDenominator = 2;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task2.4.setB.liqu")){
                startNumerator = 3;
                startDenominator = 4;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task2.4.setC.liqu")){
                startNumerator = 7;
                startDenominator = 3;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3aPlus.1.setA.area")){
                startNumerator = 3;
                startDenominator = 5;
                representation = "area";
            }
            else if (taskID.Equals("task3aPlus.1.setB.area")){
                startNumerator = 4;
                startDenominator = 7;
                representation = "area";
            }
            else if (taskID.Equals("task3aPlus.1.setC.area")){
                startNumerator = 12;
                startDenominator = 9;
                representation = "number line";
            }
            else if (taskID.Equals("task3aPlus.1.setA.numb")){
                startNumerator = 3;
                startDenominator = 5;
                representation = "number line";
            }
            else if (taskID.Equals("task3aPlus.1.setB.numb")){
                startNumerator = 4;
                startDenominator = 7;
                representation = "number line";
            }
            else if (taskID.Equals("task3aPlus.1.setC.numb")){
                startNumerator = 12;
                startDenominator = 9;
                representation = "number line";
            }
            else if (taskID.Equals("task3aPlus.1.setA.sets")){
                startNumerator = 3;
                startDenominator = 5;
                representation = "sets";
            }
            else if (taskID.Equals("task3aPlus.1.setB.sets")){
                startNumerator = 4;
                startDenominator = 7;
                representation = "sets";
            }
            else if (taskID.Equals("task3aPlus.1.setC.sets")){
                startNumerator = 12;
                startDenominator = 9;
                representation = "sets";
            }
            else if (taskID.Equals("task3aPlus.1.setA.liqu")){
                startNumerator = 3;
                startDenominator = 5;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3aPlus.1.setB.liqu")){
                startNumerator = 4;
                startDenominator = 7;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3aPlus.1.setC.liqu")){
                startNumerator = 12;
                startDenominator = 9;
                representation = "liquid measures";
            }

            else if (taskID.Equals("task3bPlus.1.setA.area")){
                startNumerator = 1;
                startDenominator = 6;
                endNumerator = 5;
                endDenominator = 12;
                finalNumerator = 2;
                finalDenominator = 12;
                resultNumerator = 7;
                resultDenominator = 12;
                representation = "area";
            }
            else if (taskID.Equals("task3bPlus.1.setB.area")){
                startNumerator = 2;
                startDenominator = 3;
                endNumerator = 2;
                endDenominator = 9;
                finalNumerator = 6;
                finalDenominator = 9;
                resultNumerator = 8;
                resultDenominator = 9;
                representation = "area";
            }
            else if (taskID.Equals("task3bPlus.1.setC.area")){
                startNumerator = 4;
                startDenominator = 3;
                endNumerator = 3;
                endDenominator = 6;
                finalNumerator = 8;
                finalDenominator = 6;
                resultNumerator = 11;
                resultDenominator = 6;
                representation = "number line";
            }
            else if (taskID.Equals("task3bPlus.1.setA.numb")){
                startNumerator = 1;
                startDenominator = 6;
                endNumerator = 5;
                endDenominator = 12;
                finalNumerator = 2;
                finalDenominator = 12;
                resultNumerator = 7;
                resultDenominator = 12;
                representation = "number line";
            }
            else if (taskID.Equals("task3bPlus.1.setB.numb")){
                startNumerator = 2;
                startDenominator = 3;
                endNumerator = 2;
                endDenominator = 9;
                finalNumerator = 6;
                finalDenominator = 9;
                resultNumerator = 8;
                resultDenominator = 9;
                representation = "number line";
            }
            else if (taskID.Equals("task3bPlus.1.setC.numb")){
                startNumerator = 4;
                startDenominator = 3;
                endNumerator = 3;
                endDenominator = 6;
                finalNumerator = 8;
                finalDenominator = 6;
                resultNumerator = 11;
                resultDenominator = 6;
                representation = "number line";
            }
            else if (taskID.Equals("task3bPlus.1.setA.sets")){
                startNumerator = 1;
                startDenominator = 6;
                endNumerator = 5;
                endDenominator = 12;
                finalNumerator = 2;
                finalDenominator = 12;
                resultNumerator = 7;
                resultDenominator = 12;
                representation = "sets";
            }
            else if (taskID.Equals("task3bPlus.1.setB.sets")){
                startNumerator = 2;
                startDenominator = 3;
                endNumerator = 2;
                endDenominator = 9;
                finalNumerator = 6;
                finalDenominator = 9;
                resultNumerator = 8;
                resultDenominator = 9;
                representation = "sets";
            }
            else if (taskID.Equals("task3bPlus.1.setC.sets")){
                startNumerator = 4;
                startDenominator = 3;
                endNumerator = 3;
                endDenominator = 6;
                finalNumerator = 8;
                finalDenominator = 6;
                resultNumerator = 11;
                resultDenominator = 6;
                representation = "sets";
            }
            else if (taskID.Equals("task3bPlus.1.setA.liqu")){
                startNumerator = 1;
                startDenominator = 6;
                endNumerator = 5;
                endDenominator = 12;
                finalNumerator = 2;
                finalDenominator = 12;
                resultNumerator = 7;
                resultDenominator = 12;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3bPlus.1.setB.liqu")){
                startNumerator = 2;
                startDenominator = 3;
                endNumerator = 2;
                endDenominator = 9;
                finalNumerator = 6;
                finalDenominator = 9;
                resultNumerator = 8;
                resultDenominator = 9;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3bPlus.1.setC.liqu")){
                startNumerator = 4;
                startDenominator = 3;
                endNumerator = 3;
                endDenominator = 6;
                finalNumerator = 8;
                finalDenominator = 6;
                resultNumerator = 11;
                resultDenominator = 6;
                representation = "liquid measures";
            }

            Debug.Log (" startNumerator: "+startNumerator+" startDenominator: "+startDenominator+" endNumerator: "+endNumerator+" endDenominator:"+endDenominator);

            FeedbackMessageString feedbackMessageString = new FeedbackMessageString (student.getLanguageEnglish(), student.getLanguageGerman(), student.getLanguageSpanish());
            feedbackMessageString.setStartNumerator(startNumerator);
            feedbackMessageString.setStartDenominator(startDenominator);
            feedbackMessageString.setEndNumerator(endNumerator);
            feedbackMessageString.setEndDenominator(endDenominator);
            feedbackMessageString.setFinalNumerator(finalNumerator);
            feedbackMessageString.setFinalDenominator(finalDenominator);
            //feedbackMessageString.setRepresentation(representation);

            tooManyReps = new FeedbackElem ();
            tooManyReps.setID("TMR");
            FeedbackMessage tooManyRepsM = new FeedbackMessage ();
            tooManyRepsM.setDidacticConceptual (feedbackMessageString.allTooManyReps_guidance());
            tooManyReps.setFeedbackMessage (tooManyRepsM);
            tooManyReps.setFeedbackType (FeedbackType.nextStep);
            Fraction nextSteptooManyRepsM = new Fraction ();
            nextSteptooManyRepsM.setRepsOnScreenBelow (7);
            tooManyReps.setNextStep (nextSteptooManyRepsM);

            S1 = new FeedbackElem ();
            S1.setID("S1");
            FeedbackMessage S1M = new FeedbackMessage ();
            S1M.setSocratic (feedbackMessageString.S1M_socratic());
            S1M.setDidacticConceptual (feedbackMessageString.S1M_didacticConceptual());
            S1.setFeedbackMessage (S1M);
            S1.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepS1 = new Fraction ();
            nextStepS1.setSpeech (true);
            S1.setNextStep (nextStepS1);

            S2 = new FeedbackElem ();
            S2.setID ("S2");
            FeedbackMessage S2M = new FeedbackMessage ();
            S2M.setSocratic (feedbackMessageString.S2M_socratic());
            S2M.setGuidance (feedbackMessageString.S2M_guidance());
            S2M.setDidacticConceptual (feedbackMessageString.S2M_didacticConceptual());
            S2M.setHighlighting(Highlighting.RepresentationToolBox);
            S2.setFeedbackMessage (S2M);
            S2.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepS2 = new Fraction ();
            nextStepS2.setAnyValue (true);
            S2.setNextStep (nextStepS2);

            S3 = new FeedbackElem ();
            S3.setID ("S3");
            FeedbackMessage S3M = new FeedbackMessage ();
            S3M.setSocratic (feedbackMessageString.S3M_socratic());
            S3M.setGuidance (feedbackMessageString.S3M_guidance());
            S3M.setDidacticConceptual (feedbackMessageString.S3M_didacticConceptual());
            S3M.setDidacticProcedural (feedbackMessageString.S3M_didacticProcedural());
            S3M.setHighlighting(Highlighting.ArrowButtons);
            S3.setFeedbackMessage (S3M);
            S3.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepS3 = new Fraction ();
            nextStepS3.setAnyValue (true);
            S3.setNextStep (nextStepS3);

            M1 = new FeedbackElem ();
            M1.setID ("M1");
            FeedbackMessage M1M = new FeedbackMessage ();
            M1M.setSocratic (feedbackMessageString.M1M_socratic());
            M1M.setGuidance (feedbackMessageString.M1M_guidance());
            M1M.setDidacticConceptual (feedbackMessageString.M1M_didacticConceptual());
            M1M.setDidacticProcedural (feedbackMessageString.M1M_didacticProcedural());
            M1M.setHighlighting(Highlighting.ArrowButtons);
            M1.setFeedbackMessage (M1M);
            M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM1 = new Fraction ();
            nextStepM1.setDenominator(endDenominator);
            M1.setNextStep (nextStepM1);

            M2 = new FeedbackElem ();
            M2.setID ("M2");
            FeedbackMessage M2M = new FeedbackMessage ();
            M2M.setSocratic (feedbackMessageString.M2M_socratic());
            M2M.setGuidance (feedbackMessageString.M2M_guidance());
            M2M.setDidacticConceptual (feedbackMessageString.M2M_didacticConceptual());
            M2M.setDidacticProcedural (feedbackMessageString.M2M_didacticProcedural());
            M2.setFeedbackMessage (M2M);
            M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM2 = new Fraction ();
            nextStepM2.setDenominator(endDenominator);
            M2.setNextStep (nextStepM2);

            CM2 = new FeedbackElem ();
            CM2.setID ("CM2");
            FeedbackMessage CM2M = new FeedbackMessage ();
            CM2M.setSocratic (feedbackMessageString.CM2M_socratic());
            CM2M.setGuidance (feedbackMessageString.CM2M_guidance());
            CM2M.setDidacticConceptual (feedbackMessageString.CM2M_didacticConceptual());
            CM2M.setDidacticProcedural (feedbackMessageString.CM2M_didacticProcedural());
            CM2.setFeedbackMessage (CM2M);
            CM2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepCM2 = new Fraction ();
            nextStepCM2.setDenominator(endDenominator);
            CM2.setNextStep (nextStepCM2);

            M3 = new FeedbackElem ();
            M3.setID ("M3");
            FeedbackMessage M3M = new FeedbackMessage ();
            M3M.setSocratic (feedbackMessageString.M3M_socratic());
            M3M.setGuidance (feedbackMessageString.M3M_guidance());
            M3M.setDidacticConceptual (feedbackMessageString.M3M_didacticConceptual());
            M3.setFeedbackMessage (M3M);
            M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM3 = new Fraction ();
            int[] valuesM3num = new int[2] {startNumerator, endNumerator};
            int[] valuesM3denom = new int[2] {startDenominator, endDenominator};
            nextStepM3.setNumerators(valuesM3num);
            nextStepM3.setDenominators(valuesM3denom);
            M3.setNextStep (nextStepM2);

            M4 = new FeedbackElem ();
            M4.setID ("M4");
            FeedbackMessage M4M = new FeedbackMessage ();
            M4M.setDidacticConceptual (feedbackMessageString.M4M_didacticConceptual());
            M4.setFeedbackMessage (M4M);
            M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepM4 = new Fraction ();
            nextStepM4.setSpeech (true);
            M4.setNextStep (nextStepM2);

            M5 = new FeedbackElem ();
            M5.setID ("M5");
            FeedbackMessage M5M = new FeedbackMessage ();
            M5M.setSocratic (feedbackMessageString.M5M_socratic());
            M5M.setGuidance (feedbackMessageString.M5M_guidance());
            M5M.setDidacticConceptual (feedbackMessageString.M5M_didacticConceptual());
            M5M.setDidacticProcedural (feedbackMessageString.M5M_didacticProcedural());
            M5.setFeedbackMessage (M5M);
            M5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM5 = new Fraction ();
            nextStepM5.setDenominator(endDenominator);
            M5.setNextStep (nextStepM2);

            CM5 = new FeedbackElem ();
            CM5.setID ("CM5");
            FeedbackMessage CM5M = new FeedbackMessage ();
            CM5M.setSocratic (feedbackMessageString.CM5M_socratic());
            CM5M.setGuidance (feedbackMessageString.CM5M_guidance());
            CM5M.setDidacticConceptual (feedbackMessageString.CM5M_didacticConceptual());
            CM5M.setDidacticProcedural (feedbackMessageString.CM5M_didacticProcedural());
            CM5.setFeedbackMessage (M5M);
            CM5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepCM5 = new Fraction ();
            nextStepCM5.setDenominator(endDenominator);
            CM5.setNextStep (nextStepCM2);

            M6 = new FeedbackElem ();
            M6.setID ("M6");
            FeedbackMessage M6M = new FeedbackMessage ();
            M6M.setSocratic (feedbackMessageString.M6M_socratic());
            M6M.setGuidance (feedbackMessageString.M6M_guidance());
            M6M.setDidacticConceptual (feedbackMessageString.M6M_didacticConceptual());
            M6M.setDidacticProcedural (feedbackMessageString.M6M_didacticProcedural());
            M6M.setHighlighting (Highlighting.ArrowButtons);
            M6.setFeedbackMessage (M6M);
            M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM6 = new Fraction ();
            nextStepM6.setNumerator(endNumerator);
            M6.setNextStep (nextStepM6);

            CM6 = new FeedbackElem ();
            CM6.setID ("CM6");
            FeedbackMessage CM6M = new FeedbackMessage ();
            CM6M.setSocratic (feedbackMessageString.M6M_socratic());
            CM6M.setGuidance (feedbackMessageString.M6M_guidance());
            CM6M.setDidacticConceptual (feedbackMessageString.CM6M_didacticConceptual());
            CM6M.setDidacticProcedural (feedbackMessageString.CM6M_didacticProcedural());
            CM6M.setHighlighting (Highlighting.ArrowButtons);
            CM6.setFeedbackMessage (CM6M);
            CM6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepCM6 = new Fraction ();
            nextStepCM6.setNumerator(1);
            nextStepCM6.setDenominator(3);
            nextStepCM6.sameRepresentation (true);
            CM6.setNextStep (nextStepCM6);

            CM6Second = new FeedbackElem ();
            CM6Second.setID ("CM6Second");
            FeedbackMessage CM6MSecond = new FeedbackMessage ();
            CM6MSecond.setSocratic (feedbackMessageString.CM6MSecond_socratic());
            CM6MSecond.setGuidance (feedbackMessageString.CM6MSecond_guidance());
            CM6MSecond.setDidacticConceptual (feedbackMessageString.CM6MSecond_didacticConceptual());
            CM6MSecond.setDidacticProcedural (feedbackMessageString.CM6MSecond_didacticProcedural());
            CM6MSecond.setHighlighting (Highlighting.ArrowButtons);
            CM6Second.setFeedbackMessage (CM6MSecond);
            CM6Second.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepCM6Second = new Fraction ();
            nextStepCM6Second.setNumerator(1);
            nextStepCM6Second.setDenominator(5);
            nextStepCM6Second.sameRepresentation (true);
            CM6Second.setNextStep (nextStepCM6Second);

            M7 = new FeedbackElem ();
            M7.setID ("M7");
            FeedbackMessage M7M = new FeedbackMessage ();
            M7M.setSocratic (feedbackMessageString.M7M_socratic());
            M7M.setGuidance (feedbackMessageString.M7M_guidance());
            M7M.setDidacticConceptual (feedbackMessageString.M7M_didacticConceptual());
            M7M.setDidacticProcedural (feedbackMessageString.M7M_didacticProcedural());
            M7.setFeedbackMessage (M7M);
            M7.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM7 = new Fraction ();
            nextStepM7.setDenominator(endDenominator);
            M7.setNextStep (nextStepM7);

            CM7 = new FeedbackElem ();
            CM7.setID ("CM7");
            FeedbackMessage CM7M = new FeedbackMessage ();
            CM7M.setSocratic (feedbackMessageString.CM7M_socratic());
            CM7M.setGuidance (feedbackMessageString.CM7M_guidance());
            CM7M.setDidacticProcedural (feedbackMessageString.CM7M_didacticProcedural());
            CM7.setFeedbackMessage (CM7M);
            CM7.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepCM7 = new Fraction ();
            nextStepCM7.sameRepresentation (true);
            CM7.setNextStep (nextStepCM7);

            M8 = new FeedbackElem ();
            M8.setID ("M8");
            FeedbackMessage M8M = new FeedbackMessage ();
            M8M.setSocratic (feedbackMessageString.M8M_socratic());
            M8M.setGuidance (feedbackMessageString.M8M_guidance());
            M8M.setDidacticConceptual (feedbackMessageString.M8M_didacticConceptual());
            M8M.setDidacticProcedural (feedbackMessageString.M8M_didacticProcedural());
            M8.setFeedbackMessage (M8M);
            M8.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM8 = new Fraction ();
            nextStepM8.setNumerator (startNumerator);
            nextStepM8.setDenominator (startDenominator);
            M8.setNextStep (nextStepM8);

            M9 = new FeedbackElem ();
            M9.setID ("M9");
            FeedbackMessage M9M = new FeedbackMessage ();
            M9M.setSocratic (feedbackMessageString.M9M_socratic());
            M9M.setGuidance (feedbackMessageString.M9M_guidance());
            M9M.setDidacticConceptual (feedbackMessageString.M9M_didacticConceptual());
            M9M.setDidacticProcedural (feedbackMessageString.M9M_didacticProcedural());
            M9.setFeedbackMessage (M9M);
            M9.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM9 = new Fraction ();
            nextStepM9.setNumerator (endNumerator);
            nextStepM9.setDenominator (endDenominator);
            M9.setNextStep (nextStepM9);

            M10 = new FeedbackElem ();
            M10.setID ("M10");
            FeedbackMessage M10M = new FeedbackMessage ();
            M10M.setSocratic (feedbackMessageString.M10M_socratic());
            M10M.setGuidance (feedbackMessageString.M10M_guidance());
            M10M.setDidacticConceptual (feedbackMessageString.M10M_didacticConceptual());
            M10M.setHighlighting (Highlighting.ComparisonBox);
            M10.setFeedbackMessage (M10M);
            M10.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM10 = new Fraction ();
            nextStepM10.setComparison (true);
            M10.setNextStep (nextStepM10);

            CM8 = new FeedbackElem ();
            CM8.setID ("CM8");
            FeedbackMessage CM8M = new FeedbackMessage ();
            CM8M.setSocratic (feedbackMessageString.CM8M_socratic());
            CM8M.setGuidance (feedbackMessageString.CM8M_guidance());
            CM8M.setDidacticConceptual (feedbackMessageString.CM8M_didacticConceptual());
            CM8M.setDidacticProcedural (feedbackMessageString.CM8M_didacticProcedural());
            CM8M.setHighlighting (Highlighting.ComparisonBox);
            CM8.setFeedbackMessage (CM8M);
            CM8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepCM8 = new Fraction ();
            nextStepCM8.setComparison (true);
            CM8.setNextStep (nextStepCM8);

            M11 = new FeedbackElem ();
            M11.setID ("M11");
            FeedbackMessage M11M = new FeedbackMessage ();
            M11M.setSocratic (feedbackMessageString.M11M_socratic());
            M11M.setGuidance (feedbackMessageString.M11M_guidance());
            M11M.setDidacticConceptual (feedbackMessageString.M11M_didacticConceptual());
            M11M.setHighlighting (Highlighting.RepresentationToolBox);
            M11.setFeedbackMessage (M11M);
            M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM11 = new Fraction ();
            nextStepM11.setNumerator (startNumerator);
            nextStepM11.setDenominator (startDenominator);
            nextStepM11.setComparison (true);
            M11.setNextStep (nextStepM11);

            M12 = new FeedbackElem ();
            M12.setID ("M12");
            FeedbackMessage M12M = new FeedbackMessage ();
            M12M.setDidacticConceptual (feedbackMessageString.M12M_didacticConceptual());
            M12.setFeedbackMessage (M12M);
            M12.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepM12 = new Fraction ();
            nextStepM12.setSpeech (true);
            M12.setNextStep (nextStepM12);

            M13 = new FeedbackElem ();
            M13.setID ("M13");
            FeedbackMessage M13M = new FeedbackMessage ();
            M13M.setSocratic (feedbackMessageString.M13M_socratic());
            M13M.setGuidance (feedbackMessageString.M13M_guidance());
            M13M.setDidacticConceptual (feedbackMessageString.M13M_didacticConceptual());
            M13M.setHighlighting (Highlighting.ComparisonBox);
            M13.setFeedbackMessage (M13M);
            M13.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM13 = new Fraction ();
            nextStepM13.setComparison (true);
            M13.setNextStep (nextStepM13);

            CM11 = new FeedbackElem ();
            CM11.setID ("CM11");
            FeedbackMessage CM11M = new FeedbackMessage ();
            CM11M.setDidacticConceptual (feedbackMessageString.CM11M_didacticConceptual());
            CM11.setFeedbackMessage (CM11M);
            CM11.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepCM11 = new Fraction ();
            nextStepCM11.setSpeech (true);
            CM11.setNextStep (nextStepCM11);

            CM12 = new FeedbackElem ();
            CM12.setID ("CM12");
            FeedbackMessage CM12M = new FeedbackMessage ();
            CM12M.setSocratic (feedbackMessageString.CM12M_socratic());
            CM12.setFeedbackMessage (CM12M);
            CM12.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepCM12 = new Fraction ();
            nextStepCM12.setSpeech (true);
            CM12.setNextStep (nextStepCM12);

            E1 = new FeedbackElem ();
            E1.setID ("E1");
            FeedbackMessage E1M = new FeedbackMessage ();
            E1M.setDidacticConceptual (feedbackMessageString.E1M_didacticConceptual());
            E1.setFeedbackMessage (E1M);
            E1.setFeedbackType (FeedbackType.affirmation);

            E2 = new FeedbackElem ();
            E2.setID ("E2");
            FeedbackMessage E2M = new FeedbackMessage ();
            E2M.setDidacticConceptual (feedbackMessageString.E2M_didacticConceptual());
            E2.setFeedbackMessage (E2M);
            Fraction nextStepE2 = new Fraction ();
            nextStepE2.setSpeech (true);
            E2.setNextStep (nextStepE2);
            E2.setFeedbackType (FeedbackType.reflection);

            CE2 = new FeedbackElem ();
            CE2.setID ("CE2");
            FeedbackMessage CE2M = new FeedbackMessage ();
            CE2M.setDidacticConceptual (feedbackMessageString.CE2M_didacticConceptual());
            CE2.setFeedbackMessage (CE2M);
            Fraction nextStepCE2 = new Fraction ();
            nextStepCE2.setSpeech (true);
            CE2.setNextStep (nextStepCE2);
            CE2.setFeedbackType (FeedbackType.reflection);

            R1 = new FeedbackElem ();
            R1.setID ("R1");
            FeedbackMessage R1M = new FeedbackMessage ();
            R1M.setDidacticConceptual (feedbackMessageString.R1M_didacticConceptual());
            R1.setFeedbackMessage (R1M);
            Fraction nextStepR1 = new Fraction ();
            nextStepR1.setSpeech (true);
            R1.setNextStep (nextStepR1);
            R1.setFeedbackType (FeedbackType.reflection);

            R2 = new FeedbackElem ();
            R2.setID ("R2");
            FeedbackMessage R2M = new FeedbackMessage ();
            R2M.setDidacticConceptual (feedbackMessageString.R2M_didacticConceptual());
            R2.setFeedbackMessage (R2M);
            Fraction nextStepR2 = new Fraction ();
            nextStepR2.setSpeech (true);
            R2.setNextStep (nextStepR2);
            R2.setFeedbackType (FeedbackType.reflection);

            O1 = new FeedbackElem ();
            O1.setID ("O1");
            FeedbackMessage O1M = new FeedbackMessage ();
            O1M.setDidacticConceptual (feedbackMessageString.O1M_didacticConceptual());
            O1.setFeedbackMessage (O1M);
            Fraction nextStepO1 = new Fraction ();
            nextStepO1.setAnyValue (true);
            O1.setNextStep (nextStepO1);
            O1.setFeedbackType (FeedbackType.taskNotFinished);

            O2 = new FeedbackElem ();
            O2.setID ("O2");
            FeedbackMessage O2M = new FeedbackMessage ();
            O2M.setDidacticConceptual (feedbackMessageString.O2M_didacticConceptual());
            O2.setFeedbackMessage (O2M);
            Fraction nextStepO2 = new Fraction ();
            nextStepO2.setAnyValue (true);
            O2.setNextStep (nextStepO2);
            O2.setFeedbackType (FeedbackType.taskNotFinished);

            FM6 = new FeedbackElem ();
            FM6.setID ("FM6");
            FeedbackMessage MF6M = new FeedbackMessage ();
            MF6M.setSocratic (feedbackMessageString.MF6M_socratic());
            MF6M.setGuidance (feedbackMessageString.MF6M_guidance());
            FM6.setFeedbackMessage (MF6M);
            FM6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepFM6 = new Fraction ();
            nextStepFM6.differntRepresentation (true);
            nextStepFM6.allSameValue(true);
            FM6.setNextStep (nextStepFM6);

            FM10 = new FeedbackElem ();
            FM10.setID ("FM10");
            FeedbackMessage MF10M = new FeedbackMessage ();
            MF10M.setSocratic (feedbackMessageString.MF10M_socratic());
            FM10.setFeedbackMessage (MF10M);
            FM10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepFM10 = new Fraction ();
            nextStepFM10.setSpeech (true);
            FM10.setNextStep (nextStepFM10);

            FM11 = new FeedbackElem ();
            FM11.setID ("FM11");
            FeedbackMessage MF11M = new FeedbackMessage ();
            MF11M.setSocratic (feedbackMessageString.MF11M_socratic());
            MF11M.setGuidance (feedbackMessageString.MF11M_guidance());
            FM11.setFeedbackMessage (MF11M);
            FM11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepFM11 = new Fraction ();
            nextStepFM11.differntRepresentation (true);
            nextStepFM11.allSameValue(true);
            FM11.setNextStep (nextStepFM11);

            FM12 = new FeedbackElem ();
            FM12.setID ("FM12");
            FeedbackMessage MF12M = new FeedbackMessage ();
            MF12M.setSocratic (feedbackMessageString.MF12M_socratic());
            MF12M.setGuidance (feedbackMessageString.MF12M_guidance());
            FM12.setFeedbackMessage (MF12M);
            FM12.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepFM12 = new Fraction ();
            nextStepFM12.allSameValue(true);
            FM12.setNextStep (nextStepFM12);

            FE1 = new FeedbackElem ();
            FE1.setID("FE1");
            FeedbackMessage MFE1M = new FeedbackMessage ();
            MFE1M.setDidacticConceptual (feedbackMessageString.MFE1M_didacticConceptual());
            FE1.setFeedbackMessage (MFE1M);
            FE1.setFeedbackType (FeedbackType.affirmation);

            FE2 = new FeedbackElem ();
            FE2.setID("FE2");
            FeedbackMessage MFE2M = new FeedbackMessage ();
            MFE2M.setDidacticConceptual (feedbackMessageString.MFE2M_didacticConceptual());
            FE2.setFeedbackMessage (MFE2M);
            FE2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepFE2 = new Fraction ();
            nextStepFE2.setSpeech (true);
            FE2.setNextStep (nextStepFE2);

            F2M1 = new FeedbackElem ();
            F2M1.setID ("F2M1");
            FeedbackMessage F2M1M = new FeedbackMessage ();
            F2M1M.setSocratic (feedbackMessageString.F2M1M_socratic());
            F2M1M.setGuidance (feedbackMessageString.F2M1M_guidance());
            F2M1M.setDidacticConceptual (feedbackMessageString.F2M1M_didacticConceptual());
            F2M1M.setDidacticProcedural (feedbackMessageString.F2M1M_didacticProcedural());
            F2M1.setFeedbackMessage (F2M1M);
            F2M1.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M1 = new Fraction ();
            nextStepF2M1.setNumeratorAnyValue (true);
            F2M1.setNextStep (nextStepF2M1);

            F2M4 = new FeedbackElem ();
            F2M4.setID ("F2M4");
            FeedbackMessage F2M4M = new FeedbackMessage ();
            F2M4M.setSocratic (feedbackMessageString.F2M4M_socratic());
            F2M4.setFeedbackMessage (F2M4M);
            F2M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepF2M4 = new Fraction ();
            nextStepF2M4.setSpeech(true);
            F2M4.setNextStep (nextStepF2M4);

            F2M6 = new FeedbackElem ();
            F2M6.setID ("F2M6");
            FeedbackMessage F2M6M = new FeedbackMessage ();
            F2M6M.setSocratic (feedbackMessageString.F2M6M_socratic());
            F2M6M.setGuidance (feedbackMessageString.F2M6M_guidance());
            F2M6M.setDidacticConceptual (feedbackMessageString.F2M6M_didacticConceptual());
            F2M6M.setDidacticProcedural (feedbackMessageString.F2M6M_didacticProcedural());
            F2M6.setFeedbackMessage (F2M6M);
            F2M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M6 = new Fraction ();
            int[] partitionValuesM6 = new int[4] {2,3,4,5};
            nextStepF2M6.setPartitionValues(partitionValuesM6);
            F2M6.setNextStep (nextStepF2M6);

            F2M7 = new FeedbackElem ();
            F2M7.setID ("F2M7");
            FeedbackMessage F2M7M = new FeedbackMessage ();
            F2M7M.setSocratic (feedbackMessageString.F2M7M_socratic());
            F2M7M.setGuidance (feedbackMessageString.F2M7M_guidance());
            F2M7M.setDidacticConceptual (feedbackMessageString.F2M7M_didacticConceptual());
            F2M7M.setDidacticProcedural (feedbackMessageString.F2M7M_didacticProcedural());
            F2M7.setFeedbackMessage (F2M7M);
            F2M7.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M7 = new Fraction ();
            int[] partitionValuesM7 = new int[4] {2,3,4,5};
            nextStepF2M7.setPartitionValues(partitionValuesM7);
            F2M7.setNextStep (nextStepF2M7);

            F2M7b = new FeedbackElem ();
            F2M7b.setID ("F2M7b");
            FeedbackMessage F2M7bM = new FeedbackMessage ();
            F2M7bM.setSocratic (feedbackMessageString.F2M7bM_socratic());
            F2M7bM.setGuidance (feedbackMessageString.F2M7bM_guidance());
            F2M7bM.setDidacticConceptual (feedbackMessageString.F2M7bM_didacticConceptual());
            F2M7bM.setDidacticProcedural (feedbackMessageString.F2M7bM_didacticProcedural());
            F2M7b.setFeedbackMessage (F2M7bM);
            F2M7b.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M7b = new Fraction ();
            int[] partitionValuesM7b = new int[4] {2,3,4,5};
            nextStepF2M7b.setPartitionValues(partitionValuesM7b);
            F2M7b.setNextStep (nextStepF2M7b);

            F2M7c = new FeedbackElem ();
            F2M7c.setID ("F2M7c");
            FeedbackMessage F2M7cM = new FeedbackMessage ();
            F2M7cM.setSocratic (feedbackMessageString.F2M7cM_socratic());
            F2M7cM.setGuidance (feedbackMessageString.F2M7cM_guidance());
            F2M7cM.setDidacticConceptual (feedbackMessageString.F2M7cM_didacticConceptual());
            F2M7cM.setDidacticProcedural (feedbackMessageString.F2M7cM_didacticProcedural());
            F2M7c.setFeedbackMessage (F2M7cM);
            F2M7c.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M7c = new Fraction ();
            int[] partitionValuesM7c = new int[4] {2,3,4,5};
            nextStepF2M7c.setPartitionValues(partitionValuesM7c);
            F2M7c.setNextStep (nextStepF2M7c);

            F2M10 = new FeedbackElem ();
            F2M10.setID ("F2M10");
            FeedbackMessage F2M10M = new FeedbackMessage ();
            F2M10M.setSocratic (feedbackMessageString.F2M10M_socratic());
            F2M10.setFeedbackMessage (F2M10M);
            F2M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepF2M10 = new Fraction ();
            nextStepF2M10.setSpeech(true);
            F2M10.setNextStep (nextStepF2M10);

            F2M11 = new FeedbackElem ();
            F2M11.setID ("F2M11");
            FeedbackMessage F2M11M = new FeedbackMessage ();
            F2M11M.setSocratic (feedbackMessageString.F2M11M_socratic());
            F2M11M.setGuidance (feedbackMessageString.F2M11M_guidance());
            F2M11.setFeedbackMessage (F2M11M);
            F2M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M11 = new Fraction ();
            int[] partitionValuesM11 = new int[4] {2,3,4,5};
            nextStepF2M11.setPartitionValues(partitionValuesM11);
            F2M11.setNextStep (nextStepF2M11);

            F2E1 = new FeedbackElem ();
            F2E1.setID("F2E1");
            FeedbackMessage MF2E1M = new FeedbackMessage ();
            MF2E1M.setDidacticConceptual (feedbackMessageString.MF2E1M_didacticConceptual());
            F2E1.setFeedbackMessage (MF2E1M);
            F2E1.setFeedbackType (FeedbackType.affirmation);

            F2E2 = new FeedbackElem ();
            F2E2.setID("F2E2");
            FeedbackMessage MF2E2M = new FeedbackMessage ();
            MF2E2M.setDidacticConceptual (feedbackMessageString.MF2E2M_didacticConceptual());
            F2E2.setFeedbackMessage (MF2E2M);
            F2E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepF2E2 = new Fraction ();
            nextStepF2E2.setSpeech (true);
            F2E2.setNextStep (nextStepF2E2);

            T24M1 = new FeedbackElem ();
            T24M1.setID ("T24M1");
            FeedbackMessage T24M1M = new FeedbackMessage ();
            T24M1M.setSocratic (feedbackMessageString.T24M1M_socratic());
            T24M1M.setGuidance (feedbackMessageString.T24M1M_guidance());
            T24M1M.setDidacticConceptual (feedbackMessageString.T24M1M_didacticConceptual());
            T24M1M.setDidacticProcedural (feedbackMessageString.T24M1M_didacticProcedural());
            T24M1M.setHighlighting (Highlighting.ArrowButtons);
            T24M1.setFeedbackMessage (T24M1M);
            T24M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M1 = new Fraction ();
            nextStepT24M1.setDenominator(startDenominator);
            T24M1.setNextStep (nextStepT24M1);

            T24M2 = new FeedbackElem ();
            T24M2.setID ("T24M2");
            FeedbackMessage T24M2M = new FeedbackMessage ();
            T24M2M.setSocratic (feedbackMessageString.T24M2M_socratic());
            T24M2M.setGuidance (feedbackMessageString.T24M2M_guidance());
            T24M2M.setDidacticConceptual (feedbackMessageString.T24M2M_didacticConceptual());
            T24M2M.setDidacticProcedural (feedbackMessageString.T24M2M_didacticProcedural());
            T24M2.setFeedbackMessage (T24M2M);
            T24M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M2 = new Fraction ();
            nextStepT24M2.setDenominator(startDenominator);
            T24M2.setNextStep (nextStepT24M2);

            T24M3 = new FeedbackElem ();
            T24M3.setID ("T24M3");
            FeedbackMessage T24M3M = new FeedbackMessage ();
            T24M3M.setSocratic (feedbackMessageString.T24M3M_socratic());
            T24M3M.setGuidance (feedbackMessageString.T24M3M_guidance());
            T24M3M.setDidacticConceptual (feedbackMessageString.T24M3M_didacticConceptual());
            T24M3.setFeedbackMessage (T24M3M);
            T24M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M3 = new Fraction ();
            nextStepT24M3.setNumerator(startNumerator);
            nextStepT24M3.setDenominator(startDenominator);
            T24M3.setNextStep (nextStepT24M3);

            T24M4 = new FeedbackElem ();
            T24M4.setID ("T24M4");
            FeedbackMessage T24M4M = new FeedbackMessage ();
            T24M4M.setDidacticConceptual (feedbackMessageString.T24M4M_didacticConceptual());
            T24M4.setFeedbackMessage (T24M4M);
            T24M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT24M4 = new Fraction ();
            nextStepT24M4.setSpeech (true);
            T24M4.setNextStep (nextStepT24M4);

            T24M5 = new FeedbackElem ();
            T24M5.setID ("T24M5");
            FeedbackMessage T24M5M = new FeedbackMessage ();
            T24M5M.setSocratic (feedbackMessageString.T24M5M_socratic());
            T24M5M.setGuidance (feedbackMessageString.T24M5M_guidance());
            T24M5M.setDidacticConceptual (feedbackMessageString.T24M5M_didacticConceptual());
            T24M5M.setDidacticProcedural (feedbackMessageString.T24M5M_didacticProcedural());
            T24M5.setFeedbackMessage (T24M5M);
            T24M5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M5 = new Fraction ();
            nextStepT24M5.setDenominator(startDenominator);
            T24M5.setNextStep (nextStepT24M5);

            T24M6 = new FeedbackElem ();
            T24M6.setID ("T24M6");
            FeedbackMessage T24M6M = new FeedbackMessage ();
            T24M6M.setSocratic (feedbackMessageString.T24M6M_socratic());
            T24M6M.setGuidance (feedbackMessageString.T24M6M_guidance());
            T24M6M.setDidacticConceptual (feedbackMessageString.T24M6M_didacticConceptual());
            T24M6M.setDidacticProcedural (feedbackMessageString.T24M6M_didacticProcedural());
            T24M6M.setHighlighting (Highlighting.ArrowButtons);
            T24M6.setFeedbackMessage (T24M6M);
            T24M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M6 = new Fraction ();
            nextStepT24M6.setNumerator(startNumerator);
            nextStepT24M6.setDenominator(startDenominator);
            nextStepT24M6.setEquivalentFraction (true);
            T24M6.setNextStep (nextStepT24M6);

            T24M7 = new FeedbackElem ();
            T24M7.setID ("T24M7");
            FeedbackMessage T24M7M = new FeedbackMessage ();
            T24M7M.setSocratic (feedbackMessageString.T24M7M_socratic());
            T24M7M.setGuidance (feedbackMessageString.T24M7M_guidance());
            T24M7M.setDidacticConceptual (feedbackMessageString.T24M7M_didacticConceptual());
            T24M7M.setDidacticProcedural (feedbackMessageString.T24M7M_didacticProcedural());
            T24M7.setFeedbackMessage (T24M7M);
            T24M7.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M7 = new Fraction ();
            nextStepT24M7.setPartitionBool (true);
            T24M7.setNextStep (nextStepT24M7);

            T24M8 = new FeedbackElem ();
            T24M8.setID ("T24M8");
            FeedbackMessage T24M8M = new FeedbackMessage ();
            T24M8M.setSocratic (feedbackMessageString.T24M8M_socratic());
            T24M8M.setGuidance (feedbackMessageString.T24M8M_guidance());
            T24M8M.setDidacticConceptual (feedbackMessageString.T24M8M_didacticConceptual());
            T24M8M.setHighlighting (Highlighting.ComparisonBox);
            T24M8.setFeedbackMessage (T24M8M);
            T24M8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M8 = new Fraction ();
            nextStepT24M8.setComparison (true);
            T24M8.setNextStep (nextStepT24M8);

            T24M9 = new FeedbackElem ();
            T24M9.setID ("T24M9");
            FeedbackMessage T24M9M = new FeedbackMessage ();
            T24M9M.setSocratic (feedbackMessageString.T24M9M_socratic());
            T24M9M.setGuidance (feedbackMessageString.T24M9M_guidance());
            T24M9M.setDidacticConceptual (feedbackMessageString.T24M9M_didacticConceptual());
            T24M9M.setHighlighting (Highlighting.RepresentationToolBox);
            T24M9.setFeedbackMessage (T24M9M);
            T24M9.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M9 = new Fraction ();
            nextStepT24M9.setComparison (true);
            T24M9.setNextStep (nextStepT24M9);

            T24M10 = new FeedbackElem ();
            T24M10.setID ("T24M10");
            FeedbackMessage T24M10M = new FeedbackMessage ();
            T24M10M.setDidacticConceptual (feedbackMessageString.T24M10M_didacticConceptual());
            T24M10.setFeedbackMessage (T24M10M);
            T24M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT24M10 = new Fraction ();
            nextStepT24M10.setSpeech (true);
            T24M10.setNextStep (nextStepT24M10);

            T24M11 = new FeedbackElem ();
            T24M11.setID ("T24M11");
            FeedbackMessage T24M11M = new FeedbackMessage ();
            T24M11M.setSocratic (feedbackMessageString.T24M11M_socratic());
            T24M11M.setGuidance (feedbackMessageString.T24M11M_guidance());
            T24M11M.setDidacticConceptual (feedbackMessageString.T24M11M_didacticConceptual());
            T24M11M.setHighlighting (Highlighting.ComparisonBox);
            T24M11.setFeedbackMessage (T24M11M);
            T24M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M11 = new Fraction ();
            nextStepT24M11.setComparison (true);
            T24M11.setNextStep (nextStepT24M11);

            T24M12 = new FeedbackElem ();
            T24M12.setID ("T24M12");
            FeedbackMessage T24M12M = new FeedbackMessage ();
            T24M12M.setSocratic (feedbackMessageString.T24M12M_socratic());
            T24M12M.setGuidance (feedbackMessageString.T24M12M_guidance());
            T24M12M.setDidacticConceptual (feedbackMessageString.T24M12M_didacticConceptual());
            T24M12M.setDidacticProcedural (feedbackMessageString.T24M12M_didacticProcedural());
            T24M12.setFeedbackMessage (T24M12M);
            T24M12.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M12 = new Fraction ();
            nextStepT24M12.setNumerator(startNumerator);
            nextStepT24M12.setDenominator(startDenominator);
            T24M12.setNextStep (nextStepT24M12);

            T24M13 = new FeedbackElem ();
            T24M13.setID ("T24M13");
            FeedbackMessage T24M13M = new FeedbackMessage ();
            T24M13M.setSocratic (feedbackMessageString.T24M13M_socratic());
            T24M13M.setGuidance (feedbackMessageString.T24M13M_guidance());
            T24M13M.setDidacticConceptual (feedbackMessageString.T24M13M_didacticConceptual());
            T24M13M.setDidacticProcedural (feedbackMessageString.T24M13M_didacticProcedural());
            T24M13.setFeedbackMessage (T24M13M);
            T24M13.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M13 = new Fraction ();
            nextStepT24M13.setNumerator(startNumerator);
            nextStepT24M13.setDenominator(startDenominator);
            T24M13.setNextStep (nextStepT24M13);

            T24E1 = new FeedbackElem ();
            T24E1.setID ("T24E1");
            FeedbackMessage T24E1M = new FeedbackMessage ();
            T24E1M.setDidacticConceptual (feedbackMessageString.T24E1M_didacticConceptual());
            T24E1.setFeedbackMessage (T24E1M);
            T24E1.setFeedbackType (FeedbackType.affirmation);

            T24E2 = new FeedbackElem ();
            T24E2.setID ("T24E2");
            FeedbackMessage T24E2M = new FeedbackMessage ();
            T24E2M.setDidacticConceptual (feedbackMessageString.T24E2M_didacticConceptual());
            T24E2.setFeedbackMessage (T24E2M);
            T24E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT24E2 = new Fraction ();
            nextStepT24E2.setSpeech (true);
            T24E2.setNextStep (nextStepT24E2);

            T26M1 = new FeedbackElem ();
            T26M1.setID ("T26M1");
            FeedbackMessage T26M1M = new FeedbackMessage ();
            T26M1M.setGuidance (feedbackMessageString.T26M1M_guidance());
            T26M1M.setSocratic (feedbackMessageString.T26M1M_socratic());
            T26M1M.setDidacticConceptual (feedbackMessageString.T26M1M_didacticConceptual());
            T26M1M.setDidacticProcedural (feedbackMessageString.T26M1M_didacticProcedural());
            T26M1M.setHighlighting (Highlighting.ArrowButtons);
            T26M1.setFeedbackMessage (T26M1M);
            T26M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M1 = new Fraction ();
            int[] values = new int[2] {startDenominator, endDenominator};
            nextStepT26M1.setDenominators (values);
            T26M1.setNextStep (nextStepT26M1);

            T26M2 = new FeedbackElem ();
            T26M2.setID ("T26M2");
            FeedbackMessage T26M2M = new FeedbackMessage ();
            T26M2M.setGuidance (feedbackMessageString.T26M2M_guidance());
            T26M2M.setSocratic (feedbackMessageString.T26M2M_socratic());
            T26M2M.setDidacticConceptual (feedbackMessageString.T26M2M_didacticConceptual());
            T26M2M.setDidacticProcedural (feedbackMessageString.T26M2M_didacticProcedural());
            T26M2M.setHighlighting (Highlighting.ArrowButtons);
            T26M2.setFeedbackMessage (T26M2M);
            T26M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M2 = new Fraction ();
            int[] values2 = new int[2] {startDenominator, endDenominator};
            nextStepT26M2.setDenominators (values2);
            T26M2.setNextStep (nextStepT26M2);

            T26M3 = new FeedbackElem ();
            T26M3.setID ("T26M3");
            FeedbackMessage T26M3M = new FeedbackMessage ();
            T26M3M.setGuidance (feedbackMessageString.T26M3M_guidance());
            T26M3M.setSocratic (feedbackMessageString.T26M3M_socratic());
            T26M3M.setDidacticConceptual (feedbackMessageString.T26M3M_didacticConceptual());
            T26M3.setFeedbackMessage (T26M3M);
            T26M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M3 = new Fraction ();
            int[] values3 = new int[2] {startNumerator, endNumerator};
            int[] values4 = new int[2] {startDenominator, endDenominator};
            nextStepT26M3.setNumerators (values3);
            nextStepT26M3.setDenominators (values4);
            T26M3.setNextStep (nextStepT26M3);

            T26M4 = new FeedbackElem ();
            T26M4.setID ("T26M4");
            FeedbackMessage T26M4M = new FeedbackMessage ();
            T26M4M.setDidacticConceptual (feedbackMessageString.T26M4M_didacticConceptual());
            T26M4.setFeedbackMessage (T26M4M);
            T26M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT26M4 = new Fraction ();
            nextStepT26M4.setSpeech (true);
            T26M4.setNextStep (nextStepT26M4);

            T26M5 = new FeedbackElem ();
            T26M5.setID ("T26M5");
            FeedbackMessage T26M5M = new FeedbackMessage ();
            T26M5M.setGuidance (feedbackMessageString.T26M5M_guidance());
            T26M5M.setSocratic (feedbackMessageString.T26M5M_socratic());
            T26M5M.setDidacticConceptual (feedbackMessageString.T26M5M_didacticConceptual());
            T26M5M.setDidacticProcedural (feedbackMessageString.T26M5M_didacticProcedural());
            T26M5.setFeedbackMessage (T26M5M);
            T26M5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M5 = new Fraction ();
            int[] valuesM5 = new int[2] {startDenominator, endDenominator};
            nextStepT26M5.setDenominators (valuesM5);
            T26M5.setNextStep (nextStepT26M5);

            T26M6 = new FeedbackElem ();
            T26M6.setID ("T26M6");
            FeedbackMessage T26M6M = new FeedbackMessage ();
            T26M6M.setGuidance (feedbackMessageString.T26M6M_guidance());
            T26M6M.setSocratic (feedbackMessageString.T26M6M_socratic());
            T26M6M.setDidacticConceptual (feedbackMessageString.T26M6M_didacticConceptual());
            T26M6M.setDidacticProcedural (feedbackMessageString.T26M6M_didacticProcedural());
            T26M6M.setHighlighting (Highlighting.ArrowButtons);
            T26M6.setFeedbackMessage (T26M6M);
            T26M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M6 = new Fraction ();
            int[] valuesM6num = new int[2] {startNumerator, endNumerator};
            int[] valuesM6den = new int[2] {startDenominator, endDenominator};
            nextStepT26M6.setNumerators (valuesM6num);
            nextStepT26M6.setDenominators (valuesM6den);
            T26M6.setNextStep (nextStepT26M6);

            T26M7 = new FeedbackElem ();
            T26M7.setID ("T26M7");
            FeedbackMessage T26M7M = new FeedbackMessage ();
            T26M7M.setGuidance (feedbackMessageString.T26M7M_guidance());
            T26M7M.setSocratic (feedbackMessageString.T26M7M_socratic());
            T26M7M.setDidacticConceptual (feedbackMessageString.T26M7M_didacticConceptual());
            T26M7M.setDidacticProcedural (feedbackMessageString.T26M7M_didacticProcedural());
            T26M7M.setHighlighting (Highlighting.ArrowButtons);
            T26M7.setFeedbackMessage (T26M7M);
            T26M7.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M7 = new Fraction ();
            int[] valuesM7num = new int[2] {startNumerator, endNumerator};
            int[] valuesM7den = new int[2] {startDenominator, endDenominator};
            nextStepT26M7.setNumerators (valuesM6num);
            nextStepT26M7.setDenominators (valuesM6den);
            T26M7.setNextStep (nextStepT26M7);

            T26M7start = new FeedbackElem ();
            T26M7start.setID ("T26M7start");
            FeedbackMessage T26M7startM = new FeedbackMessage ();
            T26M7startM.setGuidance (feedbackMessageString.T26M7Mstart_guidance());
            T26M7startM.setSocratic (feedbackMessageString.T26M7Mstart_socratic());
            T26M7startM.setDidacticConceptual (feedbackMessageString.T26M7Mstart_didacticConceptual());
            T26M7startM.setDidacticProcedural (feedbackMessageString.T26M7Mstart_didacticProcedural());
            T26M7startM.setHighlighting (Highlighting.ArrowButtons);
            T26M7start.setFeedbackMessage (T26M7startM);
            T26M7start.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M7start = new Fraction ();
            nextStepT26M7start.setNumerator (endNumerator);
            nextStepT26M7start.setDenominator (endDenominator);
            T26M7start.setNextStep (nextStepT26M7start);

            T26M7end = new FeedbackElem ();
            T26M7end.setID ("T26M7end");
            FeedbackMessage T26M7endM = new FeedbackMessage ();
            T26M7endM.setGuidance (feedbackMessageString.T26M7Mend_guidance());
            T26M7endM.setSocratic (feedbackMessageString.T26M7Mend_socratic());
            T26M7endM.setDidacticConceptual (feedbackMessageString.T26M7Mend_didacticConceptual());
            T26M7endM.setDidacticProcedural (feedbackMessageString.T26M7Mend_didacticProcedural());
            T26M7endM.setHighlighting (Highlighting.ArrowButtons);
            T26M7end.setFeedbackMessage (T26M7endM);
            T26M7end.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M7end = new Fraction ();
            nextStepT26M7end.setNumerator (startNumerator);
            nextStepT26M7end.setDenominator (startDenominator);
            T26M7end.setNextStep (nextStepT26M7end);

            T26M8 = new FeedbackElem ();
            T26M8.setID ("T26M8");
            FeedbackMessage T26M8M = new FeedbackMessage ();
            T26M8M.setGuidance (feedbackMessageString.T26M8M_guidance());
            T26M8M.setSocratic (feedbackMessageString.T26M8M_socratic());
            T26M8M.setDidacticConceptual (feedbackMessageString.T26M8M_didacticConceptual());
            T26M8M.setHighlighting (Highlighting.ComparisonBox);
            T26M8.setFeedbackMessage (T26M8M);
            T26M8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M8 = new Fraction ();
            nextStepT26M8.sameRepresentation (true);
            T26M8.setNextStep (nextStepT26M8);

            T26M10 = new FeedbackElem ();
            T26M10.setID ("T26M10");
            FeedbackMessage T26M10M = new FeedbackMessage ();
            T26M10M.setDidacticConceptual (feedbackMessageString.T26M10M_didacticConceptual());
            T26M10.setFeedbackMessage (T26M10M);
            T26M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT26M10 = new Fraction ();
            nextStepT26M10.setSpeech (true);
            T26M10.setNextStep (nextStepT26M10);

            T26M11 = new FeedbackElem ();
            T26M11.setID ("T26M11");
            FeedbackMessage T26M11M = new FeedbackMessage ();
            T26M11M.setGuidance (feedbackMessageString.T26M11M_guidance());
            T26M11M.setSocratic (feedbackMessageString.T26M11M_socratic());
            T26M11M.setDidacticConceptual (feedbackMessageString.T26M11M_didacticConceptual());
            T26M11M.setHighlighting (Highlighting.ComparisonBox);
            T26M11.setFeedbackMessage (T26M11M);
            T26M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M11 = new Fraction ();
            nextStepT26M11.setComparison (true);
            T26M11.setNextStep (nextStepT26M11);

            T26E1 = new FeedbackElem ();
            T26E1.setID ("T26E1");
            FeedbackMessage T26E1M = new FeedbackMessage ();
            T26E1M.setDidacticConceptual (feedbackMessageString.T26E1M_didacticConceptual());
            T26E1.setFeedbackMessage (T26E1M);
            T26E1.setFeedbackType (FeedbackType.affirmation);

            T26E2 = new FeedbackElem ();
            T26E2.setID ("T26E2");
            FeedbackMessage T26E2M = new FeedbackMessage ();
            T26E2M.setDidacticConceptual (feedbackMessageString.T26E2M_didacticConceptual());
            T26E2.setFeedbackMessage (T26E2M);
            T26E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT26E2 = new Fraction ();
            nextStepT26E2.setSpeech (true);
            T26E2.setNextStep (nextStepT26E2);

            T3aP1M1 = new FeedbackElem ();
            T3aP1M1.setID ("T3aP1M1");
            FeedbackMessage T3aP1M1M = new FeedbackMessage ();
            T3aP1M1M.setSocratic (feedbackMessageString.T3aP1M1M_socratic());
            T3aP1M1M.setGuidance (feedbackMessageString.T3aP1M1M_guidance());
            T3aP1M1M.setDidacticConceptual (feedbackMessageString.T3aP1M1M_didacticConceptual());
            T3aP1M1M.setDidacticProcedural (feedbackMessageString.T3aP1M1M_didacticProcedural());
            T3aP1M1M.setHighlighting (Highlighting.ArrowButtons);
            T3aP1M1.setFeedbackMessage (T3aP1M1M);
            T3aP1M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M1 = new Fraction ();
            nextStepT3aP1M1.setDenominator (startDenominator);
            T3aP1M1.setNextStep (nextStepT3aP1M1);

            T3aP1M2 = new FeedbackElem ();
            T3aP1M2.setID ("T3aP1M2");
            FeedbackMessage T3aP1M2M = new FeedbackMessage ();
            T3aP1M2M.setSocratic (feedbackMessageString.T3aP1M2M_socratic());
            T3aP1M2M.setGuidance (feedbackMessageString.T3aP1M2M_guidance());
            T3aP1M2M.setDidacticConceptual (feedbackMessageString.T3aP1M2M_didacticConceptual());
            T3aP1M2M.setDidacticProcedural (feedbackMessageString.T3aP1M2M_didacticProcedural());
            T3aP1M2.setFeedbackMessage (T3aP1M2M);
            T3aP1M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M2 = new Fraction ();
            nextStepT3aP1M2.setDenominator (startDenominator);
            T3aP1M2.setNextStep (nextStepT3aP1M2);

            T3aP1M3 = new FeedbackElem ();
            T3aP1M3.setID ("T3aP1M3");
            FeedbackMessage T3aP1M3M = new FeedbackMessage ();
            T3aP1M3M.setSocratic (feedbackMessageString.T3aP1M3M_socratic());
            T3aP1M3M.setGuidance (feedbackMessageString.T3aP1M3M_guidance());
            T3aP1M3M.setDidacticConceptual (feedbackMessageString.T3aP1M3M_didacticConceptual());
            T3aP1M3.setFeedbackMessage (T3aP1M3M);
            T3aP1M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M3 = new Fraction ();
            nextStepT3aP1M3.setFractionForAdditionTask(startDenominator, startNumerator);
            T3aP1M3.setNextStep (nextStepT3aP1M3);

            T3aP1M4 = new FeedbackElem ();
            T3aP1M4.setID ("T3aP1M4");
            FeedbackMessage T3aP1M4M = new FeedbackMessage ();
            T3aP1M4M.setDidacticConceptual (feedbackMessageString.T3aP1M4M_didacticConceptual());
            T3aP1M4.setFeedbackMessage (T3aP1M4M);
            T3aP1M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3aP1M4 = new Fraction ();
            nextStepT3aP1M4.setSpeech (true);
            T3aP1M4.setNextStep (nextStepT3aP1M4);

            T3aP1M5 = new FeedbackElem ();
            T3aP1M5.setID ("T3aP1M5");
            FeedbackMessage T3aP1M5M = new FeedbackMessage ();
            T3aP1M5M.setSocratic (feedbackMessageString.T3aP1M5M_socratic());
            T3aP1M5M.setGuidance (feedbackMessageString.T3aP1M5M_guidance());
            T3aP1M5M.setDidacticConceptual (feedbackMessageString.T3aP1M5M_didacticConceptual());
            T3aP1M5M.setDidacticProcedural (feedbackMessageString.T3aP1M5M_didacticProcedural());
            T3aP1M5.setFeedbackMessage (T3aP1M5M);
            T3aP1M5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M5 = new Fraction ();
            nextStepT3aP1M5.setDenominator (startDenominator);
            T3aP1M5.setNextStep (nextStepT3aP1M5);

            T3aP1M6 = new FeedbackElem ();
            T3aP1M6.setID ("T3aP1M6");
            FeedbackMessage T3aP1M6M = new FeedbackMessage ();
            T3aP1M6M.setSocratic (feedbackMessageString.T3aP1M6M_socratic());
            T3aP1M6M.setGuidance (feedbackMessageString.T3aP1M6M_guidance());
            T3aP1M6M.setDidacticConceptual (feedbackMessageString.T3aP1M6M_didacticConceptual());
            T3aP1M6M.setDidacticProcedural (feedbackMessageString.T3aP1M6M_didacticProcedural());
            T3aP1M6M.setHighlighting (Highlighting.ArrowButtons);
            T3aP1M6.setFeedbackMessage (T3aP1M6M);
            T3aP1M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3aP1M6 = new Fraction ();
            nextStepT3aP1M6.setFractionForAdditionTask(startDenominator, startNumerator);
            T3aP1M6.setNextStep (nextStepT3aP1M6);

            T3aP1M7 = new FeedbackElem ();
            T3aP1M7.setID ("T3aP1M7");
            FeedbackMessage T3aP1M7M = new FeedbackMessage ();
            T3aP1M7M.setSocratic (feedbackMessageString.T3aP1M7M_socratic());
            T3aP1M7M.setGuidance (feedbackMessageString.T3aP1M7M_guidance());
            T3aP1M7.setFeedbackMessage (T3aP1M7M);
            T3aP1M7.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M7 = new Fraction ();
            nextStepT3aP1M7.setFractionForAdditionTaskEnd(startDenominator, startNumerator);
            T3aP1M7.setNextStep (nextStepT3aP1M7);

            T3aP1M8 = new FeedbackElem ();
            T3aP1M8.setID ("T3aP1M8");
            FeedbackMessage T3aP1M8M = new FeedbackMessage ();
            T3aP1M8M.setSocratic (feedbackMessageString.T3aP1M8M_socratic());
            T3aP1M8M.setGuidance (feedbackMessageString.T3aP1M8M_guidance());
            T3aP1M8.setFeedbackMessage (T3aP1M8M);
            T3aP1M8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M8 = new Fraction ();
            nextStepT3aP1M8.setFractionForAdditionTaskEnd(startDenominator, startNumerator);
            T3aP1M8.setNextStep (nextStepT3aP1M8);

            T3aP1M10 = new FeedbackElem ();
            T3aP1M10.setID ("T3aP1M10");
            FeedbackMessage T3aP1M10M = new FeedbackMessage ();
            T3aP1M10M.setDidacticConceptual (feedbackMessageString.T3aP1M10M_didacticConceptual());
            T3aP1M10.setFeedbackMessage (T3aP1M10M);
            T3aP1M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3aP1M10 = new Fraction ();
            nextStepT3aP1M10.setSpeech(true);
            T3aP1M10.setNextStep (nextStepT3aP1M10);

            T3aP1M11 = new FeedbackElem ();
            T3aP1M11.setID ("T3aP1M11");
            FeedbackMessage T3aP1M11M = new FeedbackMessage ();
            T3aP1M11M.setSocratic (feedbackMessageString.T3aP1M11M_socratic());
            T3aP1M11M.setGuidance (feedbackMessageString.T3aP1M11M_guidance());
            T3aP1M11M.setDidacticConceptual (feedbackMessageString.T3aP1M11M_didacticConceptual());
            T3aP1M11.setFeedbackMessage (T3aP1M11M);
            T3aP1M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3aP1M11 = new Fraction ();
            nextStepT3aP1M11.setAdditionBox (true);
            T3aP1M11.setNextStep (nextStepT3aP1M11);

            T3aP1E1 = new FeedbackElem ();
            T3aP1E1.setID ("T3aP1E1");
            FeedbackMessage T3aP1E1M = new FeedbackMessage ();
            T3aP1E1M.setDidacticConceptual (feedbackMessageString.T3aP1E1M_didacticConceptual());
            T3aP1E1.setFeedbackMessage (T3aP1E1M);
            T3aP1E1.setFeedbackType (FeedbackType.affirmation);

            T3aP1E2 = new FeedbackElem ();
            T3aP1E2.setID ("T3aP1E2");
            FeedbackMessage T3aP1E2M = new FeedbackMessage ();

            T3aP1E2M.setDidacticConceptual (feedbackMessageString.T3aP1E2M_didacticConceptual());
            T3aP1E2.setFeedbackMessage (T3aP1E2M);
            T3aP1E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3aPE2 = new Fraction ();
            nextStepT3aPE2.setSpeech(true);
            T3aP1E2.setNextStep (nextStepT3aPE2);

            T3bP1S3 = new FeedbackElem ();
            T3bP1S3.setID ("T3bP1S3");
            FeedbackMessage T3bP1S3M = new FeedbackMessage ();
            T3bP1S3M.setSocratic (feedbackMessageString.T3bP1_affirmationInstruction_socratic());
            T3bP1S3M.setGuidance (feedbackMessageString.T3bP1_affirmationInstruction_guidance());
            T3bP1S3M.setDidacticConceptual (feedbackMessageString.T3bP1_affirmationInstruction_didacticConceptual());
            T3bP1S3M.setDidacticProcedural (feedbackMessageString.T3bP1_affirmationInstruction_didacticProcedural());
            T3bP1S3.setFeedbackMessage (T3bP1S3M);
            T3bP1S3.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1S3 = new Fraction ();
            nextStepT3bP1S3.setAnyValue (true);
            T3bP1S3.setNextStep (nextStepT3bP1S3);

            T3bP1M1 = new FeedbackElem ();
            T3bP1M1.setID ("T3bP1M1");
            FeedbackMessage T3bP1M1M = new FeedbackMessage ();
            T3bP1M1M.setSocratic (feedbackMessageString.T3bP1M1_socratic());
            T3bP1M1M.setGuidance (feedbackMessageString.T3bP1M1_guidance());
            T3bP1M1M.setDidacticConceptual (feedbackMessageString.T3bP1M1_didacticConceptual());
            T3bP1M1M.setDidacticProcedural (feedbackMessageString.T3bP1M1_didacticProcedural());
            T3bP1M1.setFeedbackMessage (T3bP1M1M);
            T3bP1M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3bP1M1 = new Fraction ();
            int[] valuesM1denom = new int[2] {startDenominator, endDenominator};
            nextStepT3bP1M1.setDenominators(valuesM1denom);
            T3bP1M1.setNextStep (nextStepT3bP1M1);

            T3bP1M2 = new FeedbackElem ();
            T3bP1M2.setID ("T3bP1M2");
            FeedbackMessage T3bP1M2M = new FeedbackMessage ();
            T3bP1M2M.setSocratic (feedbackMessageString.T3bP1M2_socratic());
            T3bP1M2M.setGuidance (feedbackMessageString.T3bP1M2_guidance());
            T3bP1M2M.setDidacticConceptual (feedbackMessageString.T3bP1M2_didacticConceptual());
            T3bP1M2M.setDidacticProcedural (feedbackMessageString.T3bP1M2_didacticProcedural());
            T3bP1M2.setFeedbackMessage (T3bP1M2M);
            T3bP1M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3bP1M2 = new Fraction ();
            nextStepT3bP1M2.setDenominator(startDenominator);
            T3bP1M2.setNextStep (nextStepT3bP1M2);

            T3bP1M3 = new FeedbackElem ();
            T3bP1M3.setID ("T3bP1M3");
            FeedbackMessage T3bP1M3M = new FeedbackMessage ();
            T3bP1M3M.setSocratic (feedbackMessageString.T3bP1M3_socratic());
            T3bP1M3M.setGuidance (feedbackMessageString.T3bP1M3_guidance());
            T3bP1M3M.setDidacticConceptual (feedbackMessageString.T3bP1M3_didacticConceptual());
            T3bP1M3.setFeedbackMessage (T3bP1M3M);
            T3bP1M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3bP1M3 = new Fraction ();
            int[] valuesT3bM3num = new int[2] {startNumerator, endNumerator};
            int[] valuesT3bM3denom = new int[2] {startDenominator, endDenominator};
            nextStepT3bP1M3.setNumerators(valuesT3bM3num);
            nextStepT3bP1M3.setDenominators(valuesT3bM3denom);
            T3bP1M3.setNextStep (nextStepT3bP1M3);

            T3bP1M4 = new FeedbackElem ();
            T3bP1M4.setID ("T3bP1M4");
            FeedbackMessage T3bP1M4M = new FeedbackMessage ();
            T3bP1M4M.setDidacticConceptual (feedbackMessageString.T3bP1M4_didacticConceptual());
            T3bP1M4.setFeedbackMessage (T3bP1M4M);
            T3bP1M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3bP1M4 = new Fraction ();
            nextStepT3bP1M4.setSpeech (true);
            T3bP1M4.setNextStep (nextStepT3bP1M4);

            T3bP1M5 = new FeedbackElem ();
            T3bP1M5.setID ("T3bP1M5");
            FeedbackMessage T3bP1M5M = new FeedbackMessage ();
            T3bP1M5M.setSocratic (feedbackMessageString.T3bP1M5_socratic());
            T3bP1M5M.setGuidance (feedbackMessageString.T3bP1M5_guidance());
            T3bP1M5M.setDidacticConceptual (feedbackMessageString.T3bP1M5_didacticConceptual());
            T3bP1M5M.setDidacticProcedural (feedbackMessageString.T3bP1M5_didacticProcedural());
            T3bP1M5.setFeedbackMessage (T3bP1M5M);
            T3bP1M5.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1M5 = new Fraction ();
            nextStepT3bP1M5.setDenominator(startDenominator);
            T3bP1M5.setNextStep (nextStepT3bP1M5);

            T3bP1M7start = new FeedbackElem ();
            T3bP1M7start.setID ("T3bP1M7start");
            FeedbackMessage T3bP1M7Mstart = new FeedbackMessage ();
            T3bP1M7Mstart.setSocratic (feedbackMessageString.T3bP1M7_socratic());
            T3bP1M7Mstart.setGuidance (feedbackMessageString.T3bP1M7First_guidance());
            T3bP1M7start.setFeedbackMessage (T3bP1M7Mstart);
            T3bP1M7start.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1M7start = new Fraction ();
            nextStepT3bP1M7start.setNumerator(startNumerator);
            nextStepT3bP1M7start.setDenominator(startDenominator);
            T3bP1M7start.setNextStep (nextStepT3bP1M7start);

            T3bP1M7end = new FeedbackElem ();
            T3bP1M7end.setID ("T3bP1M7end");
            FeedbackMessage T3bP1M7Mend = new FeedbackMessage ();
            T3bP1M7Mend.setSocratic (feedbackMessageString.T3bP1M7_socratic());
            T3bP1M7Mend.setGuidance (feedbackMessageString.T3bP1M7Second_guidance());
            T3bP1M7end.setFeedbackMessage (T3bP1M7Mend);
            T3bP1M7end.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1M7end = new Fraction ();
            nextStepT3bP1M7end.setNumerator(endNumerator);
            nextStepT3bP1M7end.setDenominator(endDenominator);
            T3bP1M7end.setNextStep (nextStepT3bP1M7end);

            T3bP1M8 = new FeedbackElem ();
            T3bP1M8.setID ("T3bP1M8");
            FeedbackMessage T3bP1M8M = new FeedbackMessage ();
            T3bP1M8M.setSocratic (feedbackMessageString.T3bP1M8_socratic());
            T3bP1M8M.setGuidance (feedbackMessageString.T3bP1M8_guidance());
            T3bP1M8M.setDidacticConceptual (feedbackMessageString.T3bP1M8_didacticConceptual());
            T3bP1M8M.setDidacticProcedural (feedbackMessageString.T3bP1M8_didacticProcedural());
            T3bP1M8.setFeedbackMessage (T3bP1M8M);
            T3bP1M8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3bP1M8 = new Fraction ();
            nextStepT3bP1M8.setDenominator(endDenominator);
            T3bP1M8.setNextStep (nextStepT3bP1M8);

            T3bP1M10 = new FeedbackElem ();
            T3bP1M10.setID ("T3bP1M10");
            FeedbackMessage T3bP1M10M = new FeedbackMessage ();
            T3bP1M10M.setDidacticConceptual (feedbackMessageString.T3bP1M10_didacticConceptual());
            T3bP1M10.setFeedbackMessage (T3bP1M10M);
            T3bP1M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3bP1M10 = new Fraction ();
            nextStepT3bP1M10.setSpeech (true);
            T3bP1M10.setNextStep (nextStepT3bP1M10);

            T3bP1M11 = new FeedbackElem ();
            T3bP1M11.setID ("T3bP1M11");
            FeedbackMessage T3bP1M11M = new FeedbackMessage ();
            T3bP1M11M.setSocratic (feedbackMessageString.T3bP1M11_socratic());
            T3bP1M11M.setGuidance (feedbackMessageString.T3bP1M11_guidance());
            T3bP1M11M.setDidacticConceptual (feedbackMessageString.T3bP1M11_didacticConceptual());
            T3bP1M11.setFeedbackMessage (T3bP1M11M);
            T3bP1M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1M11 = new Fraction ();
            nextStepT3bP1M11.setAdditionBox (true);
            T3bP1M11.setNextStep (nextStepT3bP1M11);

            T3bP1E1 = new FeedbackElem ();
            T3bP1E1.setID ("T3bP1E1");
            FeedbackMessage T3bP1E1M = new FeedbackMessage ();
            T3bP1E1M.setDidacticConceptual (feedbackMessageString.T3bP1E1_didacticConceptual());
            T3bP1E1.setFeedbackMessage (T3bP1E1M);
            T3bP1E1.setFeedbackType (FeedbackType.affirmation);

            T3bP1E2 = new FeedbackElem ();
            T3bP1E2.setID ("T3bP1E2");
            FeedbackMessage T3bP1E2M = new FeedbackMessage ();
            T3bP1E2M.setDidacticConceptual (feedbackMessageString.T3bP1E2_didacticConceptual());
            T3bP1E2.setFeedbackMessage (T3bP1E2M);
            T3bP1E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3bP1E2 = new Fraction ();
            nextStepT3bP1E2.setSpeech(true);
            T3bP1E2.setNextStep (nextStepT3bP1E2);
        }
 public void setFeedbackMessage(FeedbackMessage value)
 {
     message = value;
 }