Presolved optimization model

[vuphamngoctan1612]

I have this model like below:
How can i know what presolver do to optimize my constraint from pic 1 to pic 2

 public static void solve(Integer limitLoad, Integer startTime, Integer endTime, Integer compTime,
            Integer[][] empSkill,
            Integer[] reqSkill, Integer reqSumEmp, List<List<TimeFrame>> banTimes) {
        Loader.loadNativeLibraries();
        // Model
        CpModel model = new CpModel();

        // #region Khai báo
        Integer numEmp = empSkill.length;

        Integer timeHorizon = endTime - compTime - startTime;

        IntVar[] sumEmpAssigned = new IntVar[timeHorizon];
        for (int t = 0; t < timeHorizon; t++) {
            sumEmpAssigned[t] = model.newIntVar(0, numEmp, "sum time[" + t + "]");
        }

        BoolVar[][] empTime = new BoolVar[numEmp][timeHorizon];
        Boolean[][] empTime2 = new Boolean[numEmp][timeHorizon];
        // 200*121 = 24200
        for (int e = 0; e < numEmp; e++) {
            for (int t = 0; t < timeHorizon; t++) {
                empTime[e][t] = model.newBoolVar("emp: " + e + " time: " + t);
                empTime2[e][t] = true;
                if (!banTimes.isEmpty()) {
                    List<TimeFrame> bantime = banTimes.get(e);

                    for (TimeFrame tmp : bantime) {
                        if (tmp.beginTime <= t + startTime && t + startTime <= tmp.endTime) {
                            model.addEquality(empTime[e][t], model.falseLiteral());
                            empTime2[e][t] = false;
                        }
                    }
                }
            }
            for (int t = 0; t < timeHorizon - 1; t++) {
                if (empTime2[e][t]) {

                    int bound = (t + compTime > timeHorizon) ? timeHorizon - t : compTime;
                    IntVar[] lstTmp = new IntVar[bound];
                    for (int next = 0; next < bound; next++) {
                        lstTmp[next] = empTime[e][t + next];
                    }
                    // model.
                    model.addEquality(LinearExpr.sum(lstTmp), 1).onlyEnforceIf(empTime[e][t]);
                }
            }
        }

        // 121
        for (int i = 0; i < timeHorizon; i++) {
            LinearArgument[] tmp = new LinearArgument[numEmp];
            for (int e = 0; e < numEmp; e++) {
                tmp[e] = empTime[e][i];
            }

            model.addEquality(sumEmpAssigned[i], LinearExpr.sum(tmp));
            model.addModuloEquality(model.newConstant(0), sumEmpAssigned[i], reqSumEmp);
        }
        // #endregion

        // #region - Nhân viên phải có đủ kỹ năng = 121*2*200 = 48400

        for (int t = 0; t < timeHorizon; t++) {
            for (int s = 0; s < reqSkill.length; s++) {
                if (reqSkill[s] != 0) {
                    BoolVar[] skillVarsForReq = new BoolVar[numEmp];
                    for (int e = 0; e < numEmp; e++) {
                        skillVarsForReq[e] = model.newBoolVar("" + e + "" + t + "" + s);
                        model.addEquality(skillVarsForReq[e], LinearExpr.newBuilder().addTerm(
                                empTime[e][t], empSkill[e][s]));
                        // if (empSkill[e][s] == 0) {
                        // model.addEquality(skillVarsForReq[e], model.falseLiteral());
                        // } else {
                        // model.addEquality(skillVarsForReq[e],
                        // model.trueLiteral()).onlyEnforceIf(empTime[e][t]);
                        // }
                    }
                    LinearExprBuilder tmpBuild = LinearExpr.newBuilder();
                    tmpBuild.addTerm(sumEmpAssigned[t], -reqSkill[s]);
                    tmpBuild.addTerm(LinearExpr.sum(skillVarsForReq), reqSumEmp);
                    model.addGreaterOrEqual(tmpBuild, 0);
                }
            }
        }
        // #endregion

        // #region Hàm mục tiêu
        model.maximize(LinearExpr.sum(sumEmpAssigned));
        // #endregion

        // Cài đặt solver và giải bài toán
        CpSolver solver = new CpSolver();
        solver.getParameters().setLogSearchProgress(true);
        solver.getParameters().setNumSearchWorkers(6);
        CpSolverStatus status = solver.solve(model);
        // Hiển thị kết quả
        if (status == CpSolverStatus.OPTIMAL || status == CpSolverStatus.FEASIBLE) {
            System.out.println("Maximum Number of Assigned Tasks: " + solver.objectiveValue() / reqSumEmp);
            for (int t = 0; t < timeHorizon; t++) {
                System.out.print(solver.value(sumEmpAssigned[t]) + " ");
            }
        } else {
            System.out.println("No solution found.");
        }
    }

[lperron]

It prints all rules that were applied in between.

Code is in cp_model_presolve.cc for the most part.